Skip to content

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

Python
32.6 KB
Raw Blame
"use client";

import { useQueryClient } from "@tanstack/react-query";
import type React from "react";
import {
  createContext,
  use,
  useCallback,
  useEffect,
  useRef,
  useState,
} from "react";
import { toast } from "sonner";
import { useCancelFileMutation } from "@/app/api/mutations/useCancelFileMutation";
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 TaskDialog from "@/components/task-dialog";
import { useAuth } from "@/contexts/auth-context";
import { useOnboardingState } from "@/hooks/use-onboarding-state";
import { trackProcessFailure, trackProcessSuccess } from "@/lib/analytics";
import {
  getKnowledgeFileIdentity,
  inferTaskFileConnectorType,
} from "@/lib/knowledge-table-state";
import {
  getTaskFailureToastDescription,
  isFileCancelled,
  resolveTaskFileError,
} from "@/lib/task-error-display";
import {
  didTaskReachCompleted,
  didTaskReachTerminalState,
  finalizeProcessingOverlaysForEnhancedTask,
  findTaskFileOverlayIndex,
  getDuplicateContentFileCount,
  getEnhancedListDisappearedFilePaths,
  getFailedFileCount,
  getSkippedFileCount,
  getSuccessfulFileCount,
  hasFailedFileEntries,
  isDeletedAtSourceFile,
  isTaskInProgressStatus,
  isTerminalFailedTask,
} from "@/lib/task-utils";

// Task interface is now imported from useGetTasksQuery
export type { Task };

export interface TaskFile {
  filename: string;
  mimetype: string;
  source_url: string;
  size: number;
  connector_type: string;
  status: "active" | "failed" | "processing" | "cancelled" | "skipped";
  task_id: string;
  created_at: string;
  updated_at: string;
  error?: string;
  /**
   * Skip reason forwarded from result.reason (e.g. "duplicate_content",
   * "deleted_at_source"). Only set when status === "skipped".
   */
  skip_reason?: string;
  /** Warning message surfaced for skipped files (e.g. duplicate_content). */
  warning?: string;
  embedding_model?: string;
  embedding_dimensions?: number;
}
interface TaskContextType {
  tasks: Task[];
  files: TaskFile[];
  addTask: (
    taskId: string,
    options?: { connectorType?: string; source?: 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>;
  cancelFile: (taskId: string, filePath: string) => Promise<void>;
  isPolling: boolean;
  isFetching: boolean;
  isMenuOpen: boolean;
  openMenu: () => void;
  toggleMenu: () => void;
  closeMenu: () => void;
  isRecentTasksExpanded: boolean;
  setRecentTasksExpanded: (expanded: boolean) => void;
  selectedTaskId: string | null;
  setSelectedTaskId: (taskId: string | null) => void;
  selectedTaskTrigger: number;
  selectTask: (taskId: string | null) => void;
  isTaskDialogOpen: boolean;
  taskDialogTaskId: string | null;
  openTaskDialog: (taskId: string) => void;
  closeTaskDialog: () => void;
  // React Query states
  isLoading: boolean;
  error: Error | null;
}

const TaskContext = createContext<TaskContextType | undefined>(undefined);

export function TaskProvider({ children }: { children: React.ReactNode }) {
  const [files, setFiles] = useState<TaskFile[]>([]);
  const [isMenuOpen, setIsMenuOpen] = useState(false);
  const [isRecentTasksExpanded, setIsRecentTasksExpanded] = useState(false);
  const [selectedTaskId, setSelectedTaskId] = useState<string | null>(null);
  const [selectedTaskTrigger, setSelectedTaskTrigger] = useState(0);
  const [taskDialogTaskId, setTaskDialogTaskId] = useState<string | null>(null);
  const [isTaskDialogOpen, setIsTaskDialogOpen] = useState(false);
  const previousTasksRef = useRef<Task[]>([]);
  const taskConnectorTypesRef = useRef<Map<string, string>>(new Map());
  const taskSourcesRef = useRef<Map<string, string>>(new Map());

  const clearTaskMetadata = useCallback((taskId: string) => {
    taskConnectorTypesRef.current.delete(taskId);
    taskSourcesRef.current.delete(taskId);
  }, []);

  const clearTaskMetadataWithoutOverlays = useCallback(
    (prevFiles: TaskFile[], nextFiles: TaskFile[]) => {
      const nextTaskIds = new Set(nextFiles.map((file) => file.task_id));
      for (const file of prevFiles) {
        if (!nextTaskIds.has(file.task_id)) {
          taskConnectorTypesRef.current.delete(file.task_id);
          taskSourcesRef.current.delete(file.task_id);
        }
      }
    },
    [],
  );
  const openTaskDialog = useCallback((taskId: string) => {
    setTaskDialogTaskId(taskId);
    setIsTaskDialogOpen(true);
  }, []);
  const closeTaskDialog = useCallback(() => {
    setIsTaskDialogOpen(false);
    setTaskDialogTaskId(null);
  }, []);
  const selectTask = useCallback((taskId: string | null) => {
    setSelectedTaskId(taskId);
    if (taskId) {
      setSelectedTaskTrigger((prev) => prev + 1);
    }
  }, []);

  const { isAuthenticated, isNoAuthMode } = useAuth();

  const queryClient = useQueryClient();

  // Use React Query hooks
  const {
    data: tasks = [],
    isLoading,
    error,
    refetch: refetchTasks,
    isFetching,
  } = useGetTasksQuery({
    enabled: isAuthenticated || isNoAuthMode,
  });

  const cancelTaskMutation = useCancelTaskMutation({
    onSuccess: (_data, variables) => {
      // Transition the task to "cancelled" in cache rather than removing it, so
      // the useEffect that watches `tasks` sees the pending→cancelled transition
      // and runs the normal terminal-state cleanup (stops spinner, clears
      // processing overlays, etc.).
      queryClient.setQueryData(
        [...TASKS_QUERY_KEY],
        (oldTasks: Task[] | undefined) => {
          if (!oldTasks) return [];
          return oldTasks.map((task) => {
            if (task.task_id !== variables.taskId) return task;
            // Mark the task and every file in it as cancelled/failed so the existing
            // terminal-state logic in the useEffect handles clean-up.
            const updatedFiles = task.files
              ? Object.fromEntries(
                  Object.entries(task.files).map(([path, info]) => [
                    path,
                    info?.status === "pending" || info?.status === "running"
                      ? {
                          ...info,
                          status: "failed" as const,
                          error: "Task cancelled by user",
                        }
                      : info,
                  ]),
                )
              : task.files;
            // Note: the useEffect that processes tasks maps "failed" file entries
            // to "cancelled" TaskFile status when the parent task is "cancelled",
            // so no extra mapping is needed here.
            return {
              ...task,
              status: "cancelled" as const,
              files: updatedFiles,
            };
          });
        },
      );

      toast.success("Task cancelled", {
        description: "Task has been cancelled successfully",
      });
    },
    onError: (error) => {
      toast.error("Failed to cancel task", {
        description: error.message,
      });
    },
  });

  const cancelFileMutation = useCancelFileMutation({
    onSuccess: (_data, variables) => {
      queryClient.setQueryData(
        [...TASKS_QUERY_KEY],
        (oldTasks: Task[] | undefined) => {
          if (!oldTasks) return [];
          return oldTasks.map((task) => {
            if (task.task_id !== variables.taskId) return task;
            const updatedFiles = task.files
              ? Object.fromEntries(
                  Object.entries(task.files).map(([path, info]) => {
                    if (path === variables.filePath) {
                      return [
                        path,
                        {
                          ...info,
                          status: "failed" as const,
                          error: "File cancelled by user",
                        },
                      ];
                    }
                    return [path, info];
                  }),
                )
              : task.files;
            return { ...task, files: updatedFiles };
          });
        },
      );

      toast.success("File cancelled", {
        description: "File has been cancelled successfully",
      });
    },
    onError: (error) => {
      // Handle the case where the file already finished processing
      if (error.message.includes("File not found or cannot be cancelled")) {
        toast.info("File already completed", {
          description: "This file has already finished processing",
        });
      } else {
        toast.error("Failed to cancel file", {
          description: error.message,
        });
      }
    },
  });

  const { isOnboardingActive } = useOnboardingState();

  const refetchSearch = useCallback(() => {
    queryClient.invalidateQueries({
      queryKey: ["search"],
      exact: false,
    });
    queryClient.invalidateQueries({
      queryKey: ["listFiles"],
      exact: false,
    });
  }, [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();
      const filesToAdd: TaskFile[] = newFiles.map((file) => ({
        filename: file.filename || "",
        mimetype: file.mimetype || "",
        source_url: file.source_url || "",
        size: file.size || 0,
        connector_type: file.connector_type || "local",
        status: "processing",
        task_id: taskId,
        created_at: now,
        updated_at: now,
        error: file.error,
        embedding_model: file.embedding_model,
        embedding_dimensions: file.embedding_dimensions,
      }));

      setFiles((prevFiles) => [...prevFiles, ...filesToAdd]);
    },
    [],
  );

  // Handle task status changes and file updates
  useEffect(() => {
    const currentTaskIds = new Set(tasks.map((task) => task.task_id));
    for (const previousTask of previousTasksRef.current) {
      if (!currentTaskIds.has(previousTask.task_id)) {
        clearTaskMetadata(previousTask.task_id);
      }
    }

    if (tasks.length === 0) {
      // Store current tasks as previous for next comparison
      previousTasksRef.current = tasks;
      return;
    }

    // Check for task status changes by comparing with previous tasks
    tasks.forEach((currentTask) => {
      const previousTask = previousTasksRef.current.find(
        (prev) => prev.task_id === currentTask.task_id,
      );

      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;

      // Process files if:
      // 1. Task is in progress (always process to keep files list updated)
      // 2. Status has changed
      // 3. New task appeared (not on initial load)
      const shouldProcessFiles =
        isTaskInProgress ||
        (previousTask && previousTask.status !== currentTask.status) ||
        (!previousTask && !isInitialLoad);

      // Only show toasts if we have previous data and status has changed
      const shouldShowToast =
        previousTask && previousTask.status !== currentTask.status;

      if (shouldProcessFiles) {
        // Process files from task and add them to files list
        if (currentTask.files && typeof currentTask.files === "object") {
          const taskFileEntries = Object.entries(currentTask.files);
          const now = new Date().toISOString();

          taskFileEntries.forEach(([filePath, fileInfo]) => {
            if (typeof fileInfo === "object" && fileInfo) {
              const fileInfoEntry = fileInfo as TaskFileEntry;
              // Use the filename from backend if available, otherwise extract from path
              const fileName =
                fileInfoEntry.filename || filePath.split("/").pop() || filePath;

              // Source-deleted cleanup is completed, not an ingest. Drop any
              // processing overlay so the knowledge table does not show a ghost row.
              if (isDeletedAtSourceFile(fileInfoEntry)) {
                setFiles((prevFiles) => {
                  const existingFileIndex = findTaskFileOverlayIndex(
                    prevFiles,
                    currentTask.task_id,
                    filePath,
                    fileName,
                  );
                  if (existingFileIndex < 0) {
                    return prevFiles;
                  }
                  return prevFiles.filter(
                    (_, index) => index !== existingFileIndex,
                  );
                });
                return;
              }

              const fileStatus = fileInfoEntry.status ?? "processing";

              // Map backend file status to our TaskFile status.
              // When the parent task is "cancelled", failed files are shown as
              // "cancelled" rather than "failed" so the table row reads
              // "Cancelled" instead of "Failed".
              let mappedStatus: TaskFile["status"];
              switch (fileStatus) {
                case "pending":
                case "running":
                  mappedStatus = "processing";
                  break;
                case "completed":
                  mappedStatus = "active";
                  break;
                case "failed":
                  mappedStatus =
                    currentTask.status === "cancelled" ? "cancelled" : "failed";
                  break;
                case "skipped":
                  mappedStatus = "skipped";
                  break;
                default:
                  mappedStatus = "processing";
              }

              const fileError = (() => {
                const resolved = resolveTaskFileError(
                  fileInfoEntry,
                  mappedStatus === "failed" ? currentTask.error : undefined,
                );
                return resolved === "Unknown error" ? undefined : resolved;
              })();

              // Extract skip reason and warning from result (set by the backend).
              // Only surface duplicate-specific UI for duplicate_content skips;
              // other reasons (e.g. deleted_at_source) are silent/informational.
              const skipReason =
                mappedStatus === "skipped"
                  ? ((
                      fileInfoEntry.result as
                        | Record<string, unknown>
                        | undefined
                    )?.reason as string | undefined)
                  : undefined;
              const fileWarning =
                mappedStatus === "skipped" &&
                skipReason === "duplicate_content" &&
                typeof (fileInfoEntry.result as Record<string, unknown>)
                  ?.warning === "string"
                  ? ((fileInfoEntry.result as Record<string, unknown>)
                      .warning as string)
                  : undefined;

              setFiles((prevFiles) => {
                const existingFileIndex = findTaskFileOverlayIndex(
                  prevFiles,
                  currentTask.task_id,
                  filePath,
                  fileName,
                );
                const existingFile =
                  existingFileIndex >= 0
                    ? prevFiles[existingFileIndex]
                    : undefined;

                const connectorType = inferTaskFileConnectorType(
                  filePath,
                  fileName,
                  existingFile?.connector_type &&
                    existingFile.connector_type !== "local"
                    ? existingFile.connector_type
                    : taskConnectorTypesRef.current.get(currentTask.task_id),
                );

                const fileEntry: TaskFile = {
                  filename: fileName,
                  mimetype: existingFile?.mimetype || "",
                  source_url: filePath,
                  size: existingFile?.size || 0,
                  connector_type: connectorType,
                  status: mappedStatus,
                  task_id: currentTask.task_id,
                  created_at:
                    typeof fileInfoEntry.created_at === "string"
                      ? fileInfoEntry.created_at
                      : now,
                  updated_at:
                    typeof fileInfoEntry.updated_at === "string"
                      ? fileInfoEntry.updated_at
                      : now,
                  error: fileError,
                  skip_reason: skipReason,
                  warning: fileWarning,
                  embedding_model:
                    typeof fileInfoEntry.embedding_model === "string"
                      ? fileInfoEntry.embedding_model
                      : undefined,
                  embedding_dimensions:
                    typeof fileInfoEntry.embedding_dimensions === "number"
                      ? fileInfoEntry.embedding_dimensions
                      : undefined,
                };

                if (existingFileIndex >= 0) {
                  // Update by file identity so newer task attempts replace older
                  // failed/success overlays for the same file.
                  const updatedFiles = [...prevFiles];
                  updatedFiles[existingFileIndex] = fileEntry;
                  return updatedFiles;
                } else {
                  // Add new file
                  return [...prevFiles, fileEntry];
                }
              });
            }
          });
        }

        if (previousTask?.files) {
          const disappearedFilePaths = getEnhancedListDisappearedFilePaths(
            currentTask,
            previousTask,
          );
          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();
          }
        }
        if (
          shouldShowToast &&
          previousTask &&
          previousTask.status !== "completed" &&
          currentTask.status === "completed"
        ) {
          const successfulFiles = getSuccessfulFileCount(currentTask);
          const skippedFiles = getSkippedFileCount(currentTask);
          const duplicateFiles = getDuplicateContentFileCount(currentTask);
          const failedFiles = getFailedFileCount(currentTask);
          const isTotalFailure = failedFiles > 0 && successfulFiles === 0;

          // Check if all failures are user cancellations
          const allFailuresAreCancellations = currentTask.files
            ? Object.values(currentTask.files).every(
                (file) => file.status !== "failed" || isFileCancelled(file),
              )
            : false;

          const firstFile = currentTask.files
            ? Object.values(currentTask.files)[0]
            : undefined;
          const embeddingModel = firstFile?.embedding_model;
          const connectorType =
            taskConnectorTypesRef.current.get(currentTask.task_id) || "local";
          const source =
            taskSourcesRef.current.get(currentTask.task_id) ||
            (connectorType === "local" ? "file" : "connector");

          if (isTotalFailure && !allFailuresAreCancellations) {
            trackProcessFailure({
              processType: "Ingestion",
              process: "Document Upload",
              category: "Knowledge",
              task_id: currentTask.task_id,
              total_files: currentTask.total_files,
              failed_files: failedFiles,
              duration_seconds: currentTask.duration_seconds,
              embedding_model: embeddingModel,
              connector_type: connectorType,
              source,
            });
          } else {
            trackProcessSuccess({
              processType: "Ingestion",
              process: "Document Upload",
              category: "Knowledge",
              task_id: currentTask.task_id,
              total_files: currentTask.total_files,
              successful_files: successfulFiles,
              failed_files: failedFiles,
              duration_seconds: currentTask.duration_seconds,
              embedding_model: embeddingModel,
              connector_type: connectorType,
              source,
            });
          }

          let description = "";
          if (failedFiles > 0) {
            if (allFailuresAreCancellations) {
              description = `${failedFiles} file${
                failedFiles !== 1 ? "s" : ""
              } cancelled`;
            } else {
              description = `${successfulFiles} file${
                successfulFiles !== 1 ? "s" : ""
              } uploaded successfully, ${failedFiles} file${
                failedFiles !== 1 ? "s" : ""
              } failed`;
            }
          } else if (duplicateFiles > 0 && successfulFiles === 0) {
            // All files were duplicate-skipped — no new content was indexed.
            description = `${duplicateFiles} file${
              duplicateFiles !== 1 ? "s" : ""
            } skipped — duplicate content already in knowledge base`;
          } else if (duplicateFiles > 0) {
            // Mix of uploaded and skipped.
            description = `${successfulFiles} file${
              successfulFiles !== 1 ? "s" : ""
            } uploaded successfully, ${duplicateFiles} file${
              duplicateFiles !== 1 ? "s" : ""
            } skipped (duplicate content)`;
          } else {
            description = `${successfulFiles} file${
              successfulFiles !== 1 ? "s" : ""
            } uploaded successfully`;
          }
          if (!isOnboardingActive) {
            const toastAction = {
              label: "View",
              onClick: () => {
                selectTask(currentTask.task_id);
                setIsMenuOpen(true);
                setIsRecentTasksExpanded(true);
              },
            };
            if (isTotalFailure && !allFailuresAreCancellations) {
              toast.error("Task failed", {
                description: getTaskFailureToastDescription(currentTask),
                action: toastAction,
              });
            } else if (allFailuresAreCancellations && failedFiles > 0) {
              toast.info("File ingestion cancelled", {
                description,
                action: toastAction,
              });
            } else if (
              duplicateFiles > 0 &&
              successfulFiles === 0 &&
              failedFiles === 0
            ) {
              toast.warning("Duplicate file skipped", {
                description,
                action: toastAction,
              });
            } else {
              toast.success("Task completed", {
                description,
                action: toastAction,
              });
            }
          }
        }

        const taskJustReachedTerminal = didTaskReachTerminalState(
          previousTask,
          currentTask,
        );

        if (didTaskReachCompleted(previousTask, currentTask)) {
          const completedHasFailures = hasFailedFileEntries(currentTask);

          async function refetchKnowledgeAfterTaskCompletion() {
            // Refetch before dropping overlays (wildcard uses listFiles, not only search).
            try {
              await Promise.all([
                queryClient.refetchQueries({
                  queryKey: ["search"],
                  exact: false,
                }),
                queryClient.refetchQueries({
                  queryKey: ["listFiles"],
                  exact: false,
                }),
              ]);
            } catch (e) {
              console.error(
                "Knowledge refetch after task completion failed",
                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());
                  }
                }
              }

              clearTaskMetadata(currentTask.task_id);

              setFiles((prevFiles) =>
                prevFiles.filter((file) => {
                  if (file.task_id !== currentTask.task_id) {
                    return true;
                  }
                  if (file.status === "failed") {
                    return completedHasFailures;
                  }
                  // Keep duplicate-content skipped overlays so the user sees the
                  // "Duplicate" badge — unless the same filename was later
                  // successfully indexed (a subsequent upload supersedes it).
                  if (file.status === "skipped") {
                    const filename = file.filename?.trim();
                    if (filename && indexedFilenames.has(filename)) {
                      return false;
                    }
                    return true;
                  }
                  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;
                }),
              );
            }
          }
          void refetchKnowledgeAfterTaskCompletion();
        } else if (taskJustReachedTerminal) {
          clearTaskMetadata(currentTask.task_id);
        }

        if (
          shouldShowToast &&
          previousTask &&
          !isTerminalFailedTask(previousTask) &&
          isTerminalFailedTask(currentTask)
        ) {
          if (!isOnboardingActive) {
            selectTask(currentTask.task_id);
            setIsMenuOpen(true);
            setIsRecentTasksExpanded(true);
          }
          // Task just failed - show error toast
          trackProcessFailure({
            processType: "Ingestion",
            process: "Document Upload",
            category: "Knowledge",
            task_id: currentTask.task_id,
            total_files: currentTask.total_files,
            failed_files: currentTask.failed_files,
            duration_seconds: currentTask.duration_seconds,
            resultValue: currentTask.error,
          });
          toast.error("Task failed", {
            description: getTaskFailureToastDescription(currentTask),
          });

          // Set chat error flag to trigger test_completion=true on health checks
          // Only for ingestion-related tasks (tasks with files are ingestion tasks)
          if (currentTask.files && Object.keys(currentTask.files).length > 0) {
            // Dispatch event that chat context can listen to
            // This avoids circular dependency issues
            if (typeof window !== "undefined") {
              window.dispatchEvent(
                new CustomEvent("ingestionFailed", {
                  detail: { taskId: currentTask.task_id },
                }),
              );
            }
          }
        }
      }
    });

    // Store current tasks as previous for next comparison
    previousTasksRef.current = tasks;
  }, [
    tasks,
    refetchSearch,
    isOnboardingActive,
    clearTaskMetadata,
    queryClient,
    selectTask,
  ]);

  const addTask = useCallback(
    (taskId: string, options?: { connectorType?: string; source?: string }) => {
      const connectorType = options?.connectorType?.trim();
      if (connectorType) {
        taskConnectorTypesRef.current.set(taskId, connectorType);
      }
      const source = options?.source?.trim();
      if (source) {
        taskSourcesRef.current.set(taskId, source);
      }
      // React Query will automatically handle polling when tasks are active
      // Just trigger a refetch to get the latest data
      setTimeout(() => {
        refetchTasks();
      }, 500);
    },
    [refetchTasks],
  );

  const refreshTasks = useCallback(async () => {
    setFiles((prevFiles) => {
      const nextFiles = prevFiles.filter(
        (file) => file.status !== "active" && file.status !== "failed",
      );
      clearTaskMetadataWithoutOverlays(prevFiles, nextFiles);
      return nextFiles;
    });
    await refetchTasks();
  }, [refetchTasks, clearTaskMetadataWithoutOverlays]);

  const cancelTask = useCallback(
    async (taskId: string) => {
      await cancelTaskMutation.mutateAsync({ taskId });
    },
    [cancelTaskMutation],
  );

  const cancelFile = useCallback(
    async (taskId: string, filePath: string) => {
      await cancelFileMutation.mutateAsync({ taskId, filePath });
    },
    [cancelFileMutation],
  );

  const toggleMenu = useCallback(() => {
    setIsMenuOpen((prev) => !prev);
  }, []);

  const openMenu = useCallback(() => {
    setIsMenuOpen(true);
  }, []);

  const closeMenu = useCallback(() => {
    setIsMenuOpen(false);
    setSelectedTaskId(null);
  }, []);

  // Determine if we're polling based on React Query's refetch interval
  const isPolling =
    isFetching &&
    tasks.some(
      (task) =>
        task.status === "pending" ||
        task.status === "running" ||
        task.status === "processing",
    );

  const value: TaskContextType = {
    tasks,
    files,
    addTask,
    addFiles,
    markTaskFilesProcessing,
    refreshTasks,
    cancelTask,
    cancelFile,
    isPolling,
    isFetching,
    isMenuOpen,
    openMenu,
    toggleMenu,
    closeMenu,
    isRecentTasksExpanded,
    setRecentTasksExpanded: setIsRecentTasksExpanded,
    selectedTaskId,
    setSelectedTaskId,
    selectedTaskTrigger,
    selectTask,
    isTaskDialogOpen,
    taskDialogTaskId,
    openTaskDialog,
    closeTaskDialog,
    isLoading,
    error,
  };

  return (
    <TaskContext.Provider value={value}>
      {children}
      {taskDialogTaskId ? (
        <TaskDialog
          open={isTaskDialogOpen}
          onOpenChange={(open) => {
            setIsTaskDialogOpen(open);
            if (!open) {
              setTaskDialogTaskId(null);
            }
          }}
          task_id={taskDialogTaskId}
          onClose={closeTaskDialog}
        />
      ) : null}
    </TaskContext.Provider>
  );
}

export function useTask() {
  const context = use(TaskContext);
  if (context === undefined) {
    throw new Error("useTask must be used within a TaskProvider");
  }
  return context;
}