Skip to content

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

Python

fix: cherry pick sync warning fix (#2421)

Wallgaubd8b5a0dd5d7
diff --git a/frontend/components/task-dialog/file-list.tsx b/frontend/components/task-dialog/file-list.tsx
index c6b082b32..a72cb0218 100644
--- a/frontend/components/task-dialog/file-list.tsx
+++ b/frontend/components/task-dialog/file-list.tsx
@@ -7,6 +7,7 @@ import { useIsCloudBrand } from "@/contexts/brand-context";
import type { Task } from "@/contexts/task-context";
import { analyzeTaskFileIngestionFailure } from "@/lib/task-error-display";
import {
+ getDeletedAtSourceMessage,
getTaskFileDialogStatusLabel,
getTaskFileName,
isTaskFileFailed,
@@ -231,10 +232,12 @@ export function TaskDialogFileList({
? "text-muted-foreground"
: failed
? "text-destructive"
- : rowStatusLabel === "Complete"
+ : rowStatusLabel === "Complete" ||
+ rowStatusLabel === "Removed"
? "text-emerald-600 dark:text-emerald-400"
: "text-muted-foreground",
)}
+ title={getDeletedAtSourceMessage(fileInfo)}
>
{statusLabel}
</span>
diff --git a/frontend/components/task-error-content.test.tsx b/frontend/components/task-error-content.test.tsx
index 6e1bcd4d1..befffac5f 100644
--- a/frontend/components/task-error-content.test.tsx
+++ b/frontend/components/task-error-content.test.tsx
@@ -99,6 +99,28 @@ describe("TaskErrorContent — cancellation display", () => {
expect(container.firstChild).toBeNull();
});
+ it("does not treat a source-deleted file as a warning", () => {
+ const task = makeTask({
+ status: "completed",
+ successful_files: 1,
+ files: {
+ "gone.pdf": {
+ status: "completed",
+ result: {
+ reason: "deleted_at_source",
+ message:
+ "File no longer exists at source; removed from index (1 chunk(s) deleted).",
+ },
+ },
+ },
+ });
+
+ const { container } = renderWithProviders(<TaskErrorContent task={task} />);
+
+ expect(container.firstChild).toBeNull();
+ expect(screen.queryByText("Warning")).not.toBeInTheDocument();
+ });
+
it("shows 'Failed' label when there are real (non-cancellation) failures", () => {
const task = makeTask({
status: "failed",
diff --git a/frontend/contexts/task-context.test.tsx b/frontend/contexts/task-context.test.tsx
index f51e30857..19b351608 100644
--- a/frontend/contexts/task-context.test.tsx
+++ b/frontend/contexts/task-context.test.tsx
@@ -696,3 +696,81 @@ describe("TaskProvider — skipped files (duplicate detection)", () => {
);
});
});
+
+describe("TaskProvider — source-deleted overlays", () => {
+ it("does not create a knowledge overlay for a source-deleted file", async () => {
+ const qc = createTestQueryClient();
+ const task = makeTask({
+ status: "running",
+ files: {
+ "file-id-1": {
+ status: "completed",
+ filename: "gone.pdf",
+ result: { reason: "deleted_at_source" },
+ },
+ },
+ });
+ server.use(
+ http.get("/api/tasks/enhanced", () =>
+ HttpResponse.json({ tasks: [task] }),
+ ),
+ );
+
+ const { result } = renderHook(() => useTask(), { wrapper: wrapper(qc) });
+
+ await waitFor(() => expect(result.current.tasks).toHaveLength(1));
+ expect(
+ result.current.files.some((file) => file.source_url === "file-id-1"),
+ ).toBe(false);
+ });
+
+ it("drops a processing overlay when the file is later deleted at the source", async () => {
+ const qc = createTestQueryClient();
+ let callCount = 0;
+ const runningTask = makeTask({
+ status: "running",
+ files: {
+ "file-id-1": { status: "running", filename: "gone.pdf" },
+ },
+ });
+ const deletedTask = makeTask({
+ status: "running",
+ files: {
+ "file-id-1": {
+ status: "completed",
+ filename: "gone.pdf",
+ result: { reason: "deleted_at_source" },
+ },
+ },
+ });
+
+ server.use(
+ http.get("/api/tasks/enhanced", () => {
+ callCount++;
+ return HttpResponse.json({
+ tasks: [callCount === 1 ? runningTask : deletedTask],
+ });
+ }),
+ );
+
+ const { result } = renderHook(() => useTask(), { wrapper: wrapper(qc) });
+
+ await waitFor(() =>
+ expect(
+ result.current.files.some((file) => file.source_url === "file-id-1"),
+ ).toBe(true),
+ );
+
+ await waitFor(() => expect(callCount).toBeGreaterThanOrEqual(2), {
+ timeout: 5000,
+ });
+
+ await waitFor(
+ () =>
+ expect(
+ result.current.files.some((file) => file.source_url === "file-id-1"),
+ ).toBe(false),
+ { timeout: 5000 },
+ );
+ });
+});
diff --git a/frontend/contexts/task-context.tsx b/frontend/contexts/task-context.tsx
index 405c3bf16..fdd8a4f6f 100644
--- a/frontend/contexts/task-context.tsx
+++ b/frontend/contexts/task-context.tsx
@@ -45,6 +45,7 @@ import {
getSkippedFileCount,
getSuccessfulFileCount,
hasFailedFileEntries,
+ isDeletedAtSourceFile,
isTaskInProgressStatus,
isTerminalFailedTask,
} from "@/lib/task-utils";
@@ -381,6 +382,27 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {
// 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.
diff --git a/frontend/lib/task-utils.test.ts b/frontend/lib/task-utils.test.ts
index 5def23fd7..add17514a 100644
--- a/frontend/lib/task-utils.test.ts
+++ b/frontend/lib/task-utils.test.ts
@@ -1,8 +1,13 @@
import { describe, expect, it } from "vitest";
-import type { TaskFileEntry } from "@/app/api/queries/useGetTasksQuery";
+import type { Task, TaskFileEntry } from "@/app/api/queries/useGetTasksQuery";
import {
countTaskFileEntriesByCategory,
+ finalizeProcessingOverlaysForEnhancedTask,
+ getDeletedAtSourceMessage,
getTaskFileDialogStatusLabel,
+ getTaskIssueFileEntries,
+ isDeletedAtSourceFile,
+ isTaskFileWarning,
isTerminalTaskStatus,
} from "./task-utils";
@@ -74,6 +79,183 @@ describe("countTaskFileEntriesByCategory — cancelled bucket", () => {
});
});
+describe("deleted_at_source is successful cleanup, not a warning", () => {
+ const deletedAtSource = entry({
+ status: "completed",
+ result: {
+ reason: "deleted_at_source",
+ message:
+ "File no longer exists at source; removed from index (1 chunk(s) deleted).",
+ },
+ });
+
+ it("does not classify a source-deleted file as a warning", () => {
+ expect(isDeletedAtSourceFile(deletedAtSource)).toBe(true);
+ expect(isTaskFileWarning(deletedAtSource)).toBe(false);
+ expect(isTaskFileWarning(entry({ status: "skipped" }))).toBe(true);
+ });
+
+ it("still does not treat a leftover skipped source-deleted file as a warning", () => {
+ expect(
+ isTaskFileWarning(
+ entry({
+ status: "skipped",
+ result: { reason: "deleted_at_source" },
+ }),
+ ),
+ ).toBe(false);
+ });
+
+ it("labels a source-deleted file Removed and keeps the cleanup message", () => {
+ expect(getTaskFileDialogStatusLabel(deletedAtSource)).toBe("Removed");
+ expect(getDeletedAtSourceMessage(deletedAtSource)).toContain(
+ "removed from index",
+ );
+ expect(getDeletedAtSourceMessage(entry({ status: "completed" }))).toBe(
+ undefined,
+ );
+ expect(
+ getDeletedAtSourceMessage(
+ entry({
+ status: "completed",
+ result: { reason: "deleted_at_source", message: " " },
+ }),
+ ),
+ ).toBeUndefined();
+ });
+
+ it("buckets a source-deleted file as completed, not warning", () => {
+ const counts = countTaskFileEntriesByCategory([
+ ["gone.pdf", deletedAtSource],
+ ]);
+ expect(counts.completed).toBe(1);
+ expect(counts.warning).toBe(0);
+ });
+
+ it("omits source-deleted files from the issue list", () => {
+ const task: Task = {
+ task_id: "t1",
+ status: "completed",
+ created_at: "2026-09-16T10:00:00Z",
+ updated_at: "2026-09-16T10:00:00Z",
+ successful_files: 1,
+ files: { "gone.pdf": deletedAtSource },
+ };
+ expect(getTaskIssueFileEntries(task)).toEqual([]);
+ });
+
+ it("drops processing overlays instead of promoting them to active", () => {
+ const task: Task = {
+ task_id: "task-1",
+ status: "running",
+ created_at: "2026-09-16T10:00:00Z",
+ updated_at: "2026-09-16T10:00:00Z",
+ files: { "file-id-1": deletedAtSource },
+ };
+ const overlays = [
+ {
+ task_id: "task-1",
+ source_url: "file-id-1",
+ status: "processing" as const,
+ },
+ {
+ task_id: "task-1",
+ source_url: "other.pdf",
+ status: "processing" as const,
+ },
+ ];
+
+ const next = finalizeProcessingOverlaysForEnhancedTask(overlays, task, [
+ "file-id-1",
+ ]);
+
+ expect(next).toEqual([
+ {
+ task_id: "task-1",
+ source_url: "other.pdf",
+ status: "processing",
+ },
+ ]);
+ });
+
+ it("drops source-deleted overlays when the whole task completes", () => {
+ const task: Task = {
+ task_id: "task-1",
+ status: "completed",
+ created_at: "2026-09-16T10:00:00Z",
+ updated_at: "2026-09-16T10:00:00Z",
+ files: { "file-id-1": deletedAtSource },
+ };
+ const overlays = [
+ {
+ task_id: "task-1",
+ source_url: "file-id-1",
+ status: "processing" as const,
+ },
+ ];
+
+ expect(finalizeProcessingOverlaysForEnhancedTask(overlays, task)).toEqual(
+ [],
+ );
+ });
+
+ it("leaves overlays for other tasks and already-active files unchanged", () => {
+ const task: Task = {
+ task_id: "task-1",
+ status: "running",
+ created_at: "2026-09-16T10:00:00Z",
+ updated_at: "2026-09-16T10:00:00Z",
+ files: { "file-id-1": deletedAtSource },
+ };
+ const overlays = [
+ {
+ task_id: "other-task",
+ source_url: "file-id-1",
+ status: "processing" as const,
+ },
+ {
+ task_id: "task-1",
+ source_url: "already.pdf",
+ status: "active" as const,
+ },
+ ];
+
+ expect(
+ finalizeProcessingOverlaysForEnhancedTask(overlays, task, ["file-id-1"]),
+ ).toEqual(overlays);
+ });
+
+ it("promotes a disappeared completed ingest overlay to active", () => {
+ const task: Task = {
+ task_id: "task-1",
+ status: "running",
+ created_at: "2026-09-16T10:00:00Z",
+ updated_at: "2026-09-16T10:00:00Z",
+ files: {},
+ };
+ const overlays = [
+ {
+ task_id: "task-1",
+ source_url: "ingested.pdf",
+ status: "processing" as const,
+ },
+ ];
+
+ expect(
+ finalizeProcessingOverlaysForEnhancedTask(overlays, task, [
+ "ingested.pdf",
+ ]),
+ ).toEqual([
+ {
+ task_id: "task-1",
+ source_url: "ingested.pdf",
+ status: "active",
+ error: undefined,
+ },
+ ]);
+ });
+});
+
describe("isTerminalTaskStatus — cancelled status", () => {
it("treats 'cancelled' as a terminal status", () => {
expect(isTerminalTaskStatus("cancelled")).toBe(true);
diff --git a/frontend/lib/task-utils.ts b/frontend/lib/task-utils.ts
index 9f1f7a375..d934adb5d 100644
--- a/frontend/lib/task-utils.ts
+++ b/frontend/lib/task-utils.ts
@@ -24,8 +24,33 @@ export type TaskFileFilterOptions = {
task?: Task;
};
+function getFileResultReason(fileInfo: TaskFileEntry): string | undefined {
+ const result = fileInfo.result;
+ if (!result || typeof result !== "object" || Array.isArray(result)) {
+ return undefined;
+ }
+ const reason = (result as { reason?: unknown }).reason;
+ return typeof reason === "string" ? reason : undefined;
+}
+
+export function isDeletedAtSourceFile(fileInfo: TaskFileEntry): boolean {
+ return getFileResultReason(fileInfo) === "deleted_at_source";
+}
+
+export function getDeletedAtSourceMessage(
+ fileInfo: TaskFileEntry,
+): string | undefined {
+ if (!isDeletedAtSourceFile(fileInfo)) {
+ return undefined;
+ }
+ const message = (fileInfo.result as { message?: unknown }).message;
+ return typeof message === "string" && message.trim()
+ ? message.trim()
+ : undefined;
+}
+
function isTaskFileCompleted(fileInfo: TaskFileEntry): boolean {
- return fileInfo.status === "completed";
+ return fileInfo.status === "completed" || isDeletedAtSourceFile(fileInfo);
}
export function isTaskFileFailed(fileInfo: TaskFileEntry): boolean {
@@ -33,7 +58,8 @@ export function isTaskFileFailed(fileInfo: TaskFileEntry): boolean {
}
export function isTaskFileWarning(fileInfo: TaskFileEntry): boolean {
- return fileInfo.status === "skipped";
+ // Source-deleted files are successful cleanup, not a skip warning.
+ return fileInfo.status === "skipped" && !isDeletedAtSourceFile(fileInfo);
}
export function getTaskFileDialogStatusLabel(
@@ -54,6 +80,9 @@ export function getTaskFileDialogStatusLabel(
}
return buildRowStatusLabel("unknown");
}
+ if (isDeletedAtSourceFile(fileInfo)) {
+ return "Removed";
+ }
if (isTaskFileWarning(fileInfo)) {
return "Warning";
}
@@ -153,7 +182,7 @@ function getTaskFileStatusCategory(
return "indexing";
}
- if (status === "completed") {
+ if (isTaskFileCompleted(fileInfo)) {
return "completed";
}
@@ -284,8 +313,8 @@ export function getSuccessfulFileCount(task: Task): number {
const skipped = getSkippedFileCount(task);
return Math.max(0, task.successful_files - skipped);
}
- return Object.values(task.files || {}).filter(
- (fileInfo) => fileInfo?.status === "completed",
+ return Object.values(task.files || {}).filter((fileInfo) =>
+ fileInfo ? isTaskFileCompleted(fileInfo) : false,
).length;
}
@@ -414,6 +443,9 @@ interface ProcessingFileOverlay {
* 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.
+ *
+ * Source-deleted cleanups are completed-but-visible: drop their overlay instead
+ * of promoting it to `active`, or the knowledge table would show a ghost ingest.
*/
export function finalizeProcessingOverlaysForEnhancedTask<
T extends ProcessingFileOverlay,
@@ -422,19 +454,27 @@ export function finalizeProcessingOverlaysForEnhancedTask<
disappearedPaths === undefined ? null : new Set(disappearedPaths);
let changed = false;
- const updated = prevFiles.map((file) => {
+ const updated: T[] = [];
+ for (const file of prevFiles) {
if (file.task_id !== currentTask.task_id) {
- return file;
+ updated.push(file);
+ continue;
}
if (pathsFilter !== null && !pathsFilter.has(file.source_url)) {
- return file;
+ updated.push(file);
+ continue;
}
// Overlays can still be "failed" until the list poll sees a retry as running.
if (file.status !== "processing" && file.status !== "failed") {
- return file;
+ updated.push(file);
+ continue;
}
const entry = currentTask.files?.[file.source_url];
+ if (entry && isDeletedAtSourceFile(entry)) {
+ changed = true;
+ continue;
+ }
if (entry && isTaskFileFailed(entry)) {
if (file.status === "failed") {
const error =
@@ -442,7 +482,8 @@ export function finalizeProcessingOverlaysForEnhancedTask<
? entry.error.trim()
: file.error;
if (error === file.error) {
- return file;
+ updated.push(file);
+ continue;
}
}
changed = true;
@@ -450,13 +491,14 @@ export function finalizeProcessingOverlaysForEnhancedTask<
typeof entry.error === "string" && entry.error.trim().length > 0
? entry.error.trim()
: file.error;
- return { ...file, status: "failed" as const, error };
+ updated.push({ ...file, status: "failed" as const, error });
+ continue;
}
// Left the enhanced list (completed files are omitted) or task finished.
changed = true;
- return { ...file, status: "active" as const, error: undefined };
- });
+ updated.push({ ...file, status: "active" as const, error: undefined });
+ }
- return changed ? (updated as T[]) : prevFiles;
+ return changed ? updated : prevFiles;
}
diff --git a/src/models/processors.py b/src/models/processors.py
index bdee0021a..0c1026828 100644
--- a/src/models/processors.py
+++ b/src/models/processors.py
@@ -416,13 +416,18 @@ class TaskProcessor:
keep_filenames: list[str] | None = None,
shared: bool = False,
connector_type: str | None = None,
+ *,
+ ignore_errors: bool = True,
) -> int:
"""Delete indexed chunks for a connector file by its STABLE id.
Deletion semantics (dual-field id match, connector/owner/shared scoping,
- rename ``keep_filenames``) live in ``connectors.chunk_cleanup``. This
- wrapper is best-effort: logs and returns 0 on failure so a cleanup miss
- never fails the task.
+ rename ``keep_filenames``) live in ``connectors.chunk_cleanup``.
+
+ Rename cleanup is best-effort (``ignore_errors=True``): logs and returns
+ 0 so a miss never fails an ingest that can still re-index the new name.
+ Source-deleted cleanup passes ``ignore_errors=False`` so a real index
+ failure fails the file task instead of reporting success.
``connector_type`` scopes the match to one connector type — the same
value the chunks were indexed under — so an id that collides with a
@@ -456,7 +461,9 @@ class TaskProcessor:
file_id=file_id,
error=str(e),
)
- return 0
+ if ignore_errors:
+ return 0
+ raise
async def process_document_standard(
self,
@@ -1159,32 +1166,46 @@ class ConnectorFileProcessor(TaskProcessor):
self.user_id, self.jwt_token
)
)
- deleted_chunks = await self._delete_connector_chunks(
- file_id,
- opensearch_client,
- self.user_id,
- shared=await self._resolve_shared(
- file_id, opensearch_client, connector_type
- ),
- connector_type=connector_type,
- )
+ try:
+ deleted_chunks = await self._delete_connector_chunks(
+ file_id,
+ opensearch_client,
+ self.user_id,
+ shared=await self._resolve_shared(
+ file_id, opensearch_client, connector_type
+ ),
+ connector_type=connector_type,
+ ignore_errors=False,
+ )
+ except Exception:
+ file_task.status = TaskStatus.FAILED
+ file_task.error = (
+ "File no longer exists at source, but removing it "
+ "from the index failed."
+ )
+ file_task.updated_at = time.time()
+ upload_task.failed_files += 1
+ return
- logger.warning(
+ logger.info(
"File no longer exists at source — removed from index",
file_id=file_id,
connection_id=self.connection_id,
deleted_chunks=deleted_chunks,
- error=str(e),
+ source_error=str(e),
)
- file_task.status = TaskStatus.SKIPPED
+ # Successful cleanup: the file is gone at the source and its
+ # chunks were removed. Mark completed (not skipped) so the
+ # tasks view does not treat this as a warning. Enhanced
+ # listing still surfaces this reason so the dialog can show
+ # it as Removed instead of omitting it like a normal ingest.
+ file_task.status = TaskStatus.COMPLETED
+ file_task.error = None
file_task.result = {
- "status": "skipped",
+ "status": "completed",
"reason": "deleted_at_source",
"deleted_chunks": deleted_chunks,
- # Human-readable message so the tasks view shows this
- # successful cleanup instead of falling back to
- # "Unknown error" for a skip with no message.
- "warning": (
+ "message": (
f"File no longer exists at source; removed from index "
f"({deleted_chunks} chunk(s) deleted)."
),
diff --git a/src/services/task_service.py b/src/services/task_service.py
index 931eb9e6f..e0b966d41 100644
--- a/src/services/task_service.py
+++ b/src/services/task_service.py
@@ -1104,6 +1104,17 @@ class TaskService:
"status": "accepted",
}
+ @staticmethod
+ def _keep_completed_file_in_list(file_task: FileTask) -> bool:
+ """Source-deleted cleanups stay visible so the UI can show Removed.
+
+ Normal completed ingests are omitted from the task file list to keep it
+ tidy. A file that was removed from the index because it disappeared at
+ the source is also completed, but dropping it would hide the cleanup.
+ """
+ result = file_task.result or {}
+ return result.get("reason") == "deleted_at_source"
+
def _serialize_file_task(self, file_task: FileTask) -> dict:
"""Serialize a FileTask to the standard dict shape."""
return {
@@ -1483,7 +1494,13 @@ class TaskService:
# the list tidy. Preview-mode tasks instead need every file
# (including completed ones) so the live preview carousel can
# still enumerate them and render their cached Docling layout.
- if file_task.status != TaskStatus.COMPLETED or upload_task.preview_mode:
+ # Source-deleted cleanups are completed but must stay visible
+ # as successful removals, not vanish like a normal ingest.
+ if (
+ file_task.status != TaskStatus.COMPLETED
+ or upload_task.preview_mode
+ or self._keep_completed_file_in_list(file_task)
+ ):
entry = self._serialize_file_task(file_task)
if file_task.status == TaskStatus.FAILED:
metadata = self._infer_failure_metadata(file_task)
@@ -1544,7 +1561,9 @@ class TaskService:
file_statuses = {}
for file_path, file_task in upload_task.file_tasks.items():
- if file_task.status.value != "completed":
+ if file_task.status.value != "completed" or self._keep_completed_file_in_list(
+ file_task
+ ):
file_statuses[file_path] = {
"status": file_task.status.value,
"result": file_task.result,
diff --git a/tests/unit/test_connector_processor_filename_dedupe.py b/tests/unit/test_connector_processor_filename_dedupe.py
index 84423de08..39f61f104 100644
--- a/tests/unit/test_connector_processor_filename_dedupe.py
+++ b/tests/unit/test_connector_processor_filename_dedupe.py
@@ -219,9 +219,11 @@ async def test_connector_processor_deletes_chunks_when_source_returns_404(
await processor.process_item(upload_task, "file-id-1", file_task)
- assert file_task.status == TaskStatus.SKIPPED
+ assert file_task.status == TaskStatus.COMPLETED
assert (file_task.result or {}).get("reason") == "deleted_at_source"
assert (file_task.result or {}).get("deleted_chunks") == 1
+ assert "warning" not in (file_task.result or {})
+ assert "removed from index" in ((file_task.result or {}).get("message") or "")
assert upload_task.successful_files == 1
# Concrete chunk deletes go through the backend write client.
backend_write_client.delete.assert_awaited_once()
@@ -241,6 +243,42 @@ async def test_connector_processor_deletes_chunks_when_source_returns_404(
assert {"connector_type": "sharepoint"} in terms
+async def test_connector_processor_fails_when_source_deleted_chunk_cleanup_errors(
+ monkeypatch,
+):
+ """If the file is gone at source but index cleanup raises, the file task
+ must fail so the UI does not report a successful removal."""
+ monkeypatch.setattr("config.settings.DISABLE_INGEST_WITH_LANGFLOW", True)
+ processor = _build_connector_processor(replace_duplicates=False)
+
+ connector = MagicMock()
+ connector.get_file_content = AsyncMock(side_effect=FileNotFoundError("404 Not Found"))
+ processor.connector_service.get_connector = AsyncMock(return_value=connector)
+ connection = MagicMock()
+ connection.connector_type = "sharepoint"
+ processor.connector_service.connection_manager = MagicMock()
+ processor.connector_service.connection_manager.get_connection = AsyncMock(
+ return_value=connection
+ )
+
+ file_task = _make_file_task()
+ upload_task = _make_upload_task()
+
+ with patch(
+ "connectors.chunk_cleanup.delete_connector_file_chunks",
+ new=AsyncMock(side_effect=RuntimeError("opensearch unavailable")),
+ ):
+ await processor.process_item(upload_task, "file-id-1", file_task)
+
+ assert file_task.status == TaskStatus.FAILED
+ assert file_task.error == (
+ "File no longer exists at source, but removing it from the index failed."
+ )
+ assert upload_task.failed_files == 1
+ assert upload_task.successful_files == 0
+
+
@pytest.mark.asyncio
async def test_connector_processor_indexes_cleaned_filename(monkeypatch):
"""MIME-enforced extensions must be indexed under the same name used for dedupe."""
@@ -473,9 +511,11 @@ async def test_langflow_connector_processor_deletes_chunks_when_source_returns_4
await processor.process_item(upload_task, "file-id-1", file_task)
- assert file_task.status == TaskStatus.SKIPPED
+ assert file_task.status == TaskStatus.COMPLETED
assert (file_task.result or {}).get("reason") == "deleted_at_source"
assert (file_task.result or {}).get("deleted_chunks") == 1
+ assert "warning" not in (file_task.result or {})
+ assert "removed from index" in ((file_task.result or {}).get("message") or "")
assert file_task.error is None
assert upload_task.successful_files == 1
assert upload_task.failed_files == 0
diff --git a/tests/unit/test_task_service.py b/tests/unit/test_task_service.py
index 62b787ef3..b77f15eac 100644
--- a/tests/unit/test_task_service.py
+++ b/tests/unit/test_task_service.py
@@ -326,6 +326,37 @@ def test_enhanced_keeps_completed_files_for_preview_tasks(task_service):
assert "fileB" in files
+def test_enhanced_keeps_source_deleted_completed_files(task_service):
+ """Successful source-deletion cleanup stays in the file list as Removed."""
+ task = UploadTask(
+ task_id="sync_task",
+ total_files=2,
+ file_tasks={
+ "fileA": FileTask(
+ file_path="fileA",
+ status=TaskStatus.COMPLETED,
+ result={
+ "status": "completed",
+ "reason": "deleted_at_source",
+ "deleted_chunks": 1,
+ "message": "File no longer exists at source; removed from index (1 chunk(s) deleted).",
+ },
+ ),
+ "fileB": FileTask(file_path="fileB", status=TaskStatus.COMPLETED),
+ },
+ status=TaskStatus.COMPLETED,
+ )
+ task_service.task_store["user1"] = {"sync_task": task}
+
+ tasks = task_service.get_all_tasks2("user1")
+
+ files = tasks[0]["files"]
+ assert "fileA" in files
+ assert files["fileA"]["status"] == "completed"
+ assert files["fileA"]["result"]["reason"] == "deleted_at_source"
+ assert "fileB" not in files
+
+
# ---------------------------------------------------------------------------
# delete_task
# ---------------------------------------------------------------------------