OpenRAG 0.8.0.dev20__tar.gz → 0.8.1__tar.gz

{openrag-0.8.0.dev20/src/openrag.egg-info → openrag-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.8.0.dev20
+Version: 0.8.1
 Summary: OpenRAG is a comprehensive Retrieval-Augmented Generation platform that enables intelligent document search and AI-powered conversations.
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
@@ -17,7 +17,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: agentd>=0.8.7
 Requires-Dist: aiofiles>=24.1.0
-Requires-Dist: authlib<2.0.0,>=1.7.2
+Requires-Dist: authlib<2.0.0,>=1.8.0
 Requires-Dist: aiohttp>=3.14.1
 Requires-Dist: cryptography>=48.0.1
 Requires-Dist: click>=8.3.3
@@ -29,7 +29,7 @@ Requires-Dist: msal>=1.29.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: idna>=3.18
 Requires-Dist: opensearch-py[async]>=3.0.0
-Requires-Dist: pyjwt>=2.13.0
+Requires-Dist: pyjwt>=2.15.1
 Requires-Dist: python-multipart>=0.0.31
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: starlette>=1.6.0
@@ -45,19 +45,20 @@ Requires-Dist: textual-fspicker>=0.6.0
 Requires-Dist: structlog>=25.4.0
 Requires-Dist: zxcvbn>=4.5.0
 Requires-Dist: prometheus-fastapi-instrumentator>=8.0.0
-Requires-Dist: litellm<2.0.0,>=1.96.2
+Requires-Dist: litellm<2.0.0,>=1.105.0
 Requires-Dist: joserfc<2.0.0,>=1.7.3
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: tiktoken>=0.7.0
 Requires-Dist: fastmcp>=3.4.0
-Requires-Dist: mcp>=1.28.1
-Requires-Dist: openai==2.24.0
+Requires-Dist: mcp>=1.30.0
+Requires-Dist: openai<3,>=2.24.0
 Requires-Dist: tenacity>=9.1.4
 Requires-Dist: pygments>=2.20.0
 Requires-Dist: pyasn1>=0.6.4
 Requires-Dist: protobuf<8,>=7.35.0
 Requires-Dist: requests>=2.33.0
-Requires-Dist: urllib3>=2.7.0
+Requires-Dist: urllib3>=2.8.0
+Requires-Dist: fsspec>=2026.6.0
 Requires-Dist: sqlmodel>=0.0.22
 Requires-Dist: sqlalchemy[asyncio]>=2.0.36
 Requires-Dist: aiosqlite>=0.20.0
@@ -66,6 +67,8 @@ Requires-Dist: asyncpg>=0.30.0
 Requires-Dist: cachetools>=5.5.0
 Provides-Extra: apm
 Requires-Dist: instana<4,>=3.17.0; extra == "apm"
+Provides-Extra: tracing
+Requires-Dist: langfuse<5,>=4.16; extra == "tracing"
 Dynamic: license-file
 
 <div align="center">

{openrag-0.8.0.dev20 → openrag-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openrag"
-version = "0.8.0.dev20"
+version = "0.8.1"
 description = "OpenRAG is a comprehensive Retrieval-Augmented Generation platform that enables intelligent document search and AI-powered conversations."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -23,7 +23,7 @@ classifiers = [
 dependencies = [
     "agentd>=0.8.7",
     "aiofiles>=24.1.0",
-    "authlib>=1.7.2,<2.0.0",
+    "authlib>=1.8.0,<2.0.0",
     "aiohttp>=3.14.1",
     "cryptography>=48.0.1",
     "click>=8.3.3",
@@ -35,7 +35,7 @@ dependencies = [
     "httpx>=0.27.0",
     "idna>=3.18",
     "opensearch-py[async]>=3.0.0",
-    "pyjwt>=2.13.0",
+    "pyjwt>=2.15.1",
     "python-multipart>=0.0.31",
     "fastapi>=0.115.0",
     "starlette>=1.6.0",
@@ -51,19 +51,20 @@ dependencies = [
     "structlog>=25.4.0",
     "zxcvbn>=4.5.0",
     "prometheus-fastapi-instrumentator>=8.0.0",
-    "litellm>=1.96.2,<2.0.0",
+    "litellm>=1.105.0,<2.0.0",
     "joserfc>=1.7.3,<2.0.0",
     "pyyaml>=6.0",
     "tiktoken>=0.7.0",
     "fastmcp>=3.4.0",
-    "mcp>=1.28.1",
-    "openai==2.24.0",
+    "mcp>=1.30.0",
+    "openai>=2.24.0,<3",
     "tenacity>=9.1.4",
     "pygments>=2.20.0",
     "pyasn1>=0.6.4",
     "protobuf>=7.35.0,<8",
     "requests>=2.33.0",
-    "urllib3>=2.7.0",
+    "urllib3>=2.8.0",
+    "fsspec>=2026.6.0",
     "sqlmodel>=0.0.22",
     "sqlalchemy[asyncio]>=2.0.36",
     "aiosqlite>=0.20.0",
@@ -83,6 +84,9 @@ dependencies = [
 # be adopted explicitly, not resolved into an install.
 # src/main.py imports it defensively, so its absence downgrades to a warning.
 apm = ["instana>=3.17.0,<4"]
+tracing = [
+    "langfuse>=4.16,<5",
+]
 
 [dependency-groups]
 dev = [
@@ -92,6 +96,10 @@ dev = [
     "pytest-cov>=4.0.0",
     "ruff>=0.15.12",
     "mypy>=2.0.0",
+    # The tracing extra, so its unit tests (tests/unit/observability) run.
+    "langfuse>=4.16,<5",
+    # Used by the Langflow Split Text component, so its unit tests run the real splitter.
+    "langchain-text-splitters>=1.1.2,<2",
 ]
 
 [project.scripts]

{openrag-0.8.0.dev20 → openrag-0.8.1}/src/agent.py

@@ -1,6 +1,10 @@
+import asyncio
 import uuid
+from contextlib import aclosing
 from typing import Any
 
+import anyio
+
 from config.config_manager import DEFAULT_SYSTEM_PROMPT
 from services.conversation_persistence_service import conversation_persistence
 from utils.langflow_utils import parse_knowledge_chunks, strip_untrusted_fence_recursive
@@ -91,13 +95,10 @@ async def _persist_error_conversation(
 
     from services.session_ownership_service import session_ownership_service
 
+    if not await session_ownership_service.claim_session(user_id, store_id):
+        raise RuntimeError("Unable to establish chat session ownership")
     conversation_state["last_activity"] = datetime.now()
     await store_conversation_thread(user_id, store_id, conversation_state)
-    try:
-        await session_ownership_service.claim_session(user_id, store_id)
-        logger.debug(f"Claimed session {store_id} for user {user_id} after stream error")
-    except Exception as e:
-        logger.warning(f"Failed to claim session ownership after stream error: {e}")
 
 
 def _stream_error_chunk(message: str, response_id: str | None = None) -> bytes:
@@ -228,6 +229,7 @@ async def async_response_stream(
 ):
     logger.info("User prompt received", prompt=prompt)
 
+    response = None
     try:
         # Build request parameters
         request_params = {
@@ -422,6 +424,10 @@ async def async_response_stream(
     except Exception:
         logger.exception("[AGENT] Streaming failed")
         raise
+    finally:
+        if response is not None:
+            with anyio.CancelScope(shield=True):
+                await response.close()
 
 
 # Generic async response function for non-streaming
@@ -494,15 +500,18 @@ async def async_stream(
     previous_response_id: str = None,
     log_prefix: str = "response",
 ):
-    async for chunk in async_response_stream(
-        client,
-        prompt,
-        model,
-        extra_headers=extra_headers,
-        previous_response_id=previous_response_id,
-        log_prefix=log_prefix,
-    ):
-        yield chunk
+    async with aclosing(
+        async_response_stream(
+            client,
+            prompt,
+            model,
+            extra_headers=extra_headers,
+            previous_response_id=previous_response_id,
+            log_prefix=log_prefix,
+        )
+    ) as stream:
+        async for chunk in stream:
+            yield chunk
 
 
 # Async langflow function (non-streaming only)
@@ -718,6 +727,7 @@ async def async_chat_stream(
             await _persist_error_conversation(user_id, store_id, conversation_state)
         except Exception as store_error:
             logger.error(f"Failed to store error conversation: {store_error}")
+            store_id = None
         yield _stream_error_chunk(display_text, store_id)
 
 
@@ -850,18 +860,13 @@ async def async_langflow_chat(
 
     # Store the conversation thread with its response_id
     if response_id:
+        from services.session_ownership_service import session_ownership_service
+
+        if not await session_ownership_service.claim_session(user_id, response_id):
+            raise RuntimeError("Unable to establish chat session ownership")
         conversation_state["last_activity"] = datetime.now()
         await store_conversation_thread(user_id, response_id, conversation_state)
 
-        # Claim session ownership for this user
-        try:
-            from services.session_ownership_service import session_ownership_service
-
-            await session_ownership_service.claim_session(user_id, response_id)
-            logger.debug(f"Claimed session {response_id} for user {user_id}")
-        except Exception as e:
-            logger.warning(f"Failed to claim session ownership: {e}")
-
         logger.debug(
             "Stored langflow conversation thread",
             user_id=user_id,
@@ -894,6 +899,16 @@ async def async_langflow_chat_stream(
     # conversation_id keeps the OpenRAG sidebar thread; previous_response_id chains
     # the Langflow session. After errors the client omits previous_response_id.
     thread_id = conversation_id or previous_response_id
+    if not _conversation_thread_in_memory(user_id, thread_id):
+        # Clients may continue using the latest Langflow id without a sidebar id.
+        thread_id = next(
+            (
+                stored_id
+                for stored_id, state in active_conversations.get(user_id, {}).items()
+                if thread_id and thread_id in state.get("response_ids", [])
+            ),
+            thread_id,
+        )
     previous_loaded_from_memory = _conversation_thread_in_memory(user_id, thread_id)
     conversation_state = get_conversation_thread(user_id, thread_id)
 
@@ -915,30 +930,74 @@ async def async_langflow_chat_stream(
     usage_data = None
     collected_chunks = []  # Store all chunks for function call data
     error_occurred = False
+    store_id = None
+    claimed_ids: set[str] = set()
+    turn_finished = False
+
+    async def persist_stream_state(*session_ids, mint_if_missing=False):
+        nonlocal store_id
+        from services.session_ownership_service import session_ownership_service
+
+        if store_id is None:
+            store_id = _resolve_conversation_store_id(
+                response_id,
+                thread_id,
+                previous_loaded_from_memory=previous_loaded_from_memory,
+                mint_if_missing=mint_if_missing,
+            )
+        if store_id is None:
+            return
+        for session_id in dict.fromkeys((store_id, *session_ids)):
+            if not session_id or session_id in claimed_ids:
+                continue
+            if not await session_ownership_service.claim_session(
+                user_id, session_id, conversation_id=store_id
+            ):
+                raise RuntimeError("Unable to establish chat session ownership")
+            claimed_ids.add(session_id)
+            response_ids = conversation_state.setdefault("response_ids", [])
+            if session_id not in response_ids:
+                response_ids.append(session_id)
+        conversation_state["last_activity"] = datetime.now()
+        await store_conversation_thread(user_id, store_id, conversation_state)
+
+    upstream = async_stream(
+        langflow_client,
+        prompt,
+        flow_id,
+        extra_headers=extra_headers,
+        previous_response_id=langflow_previous_response_id,
+        log_prefix="langflow",
+    )
 
     try:
-        async for chunk in async_stream(
-            langflow_client,
-            prompt,
-            flow_id,
-            extra_headers=extra_headers,
-            previous_response_id=langflow_previous_response_id,
-            log_prefix="langflow",
-        ):
+        async for chunk in upstream:
             # Extract text content to build full response for history
+            chunk_ids = []
             try:
                 import json
 
                 chunk_data = json.loads(chunk.decode("utf-8"))
                 collected_chunks.append(chunk_data)  # Collect all chunk data
 
+                # Own every response/session ID callers can use for continuation,
+                # not tool item IDs. OpenAI events may nest the ID in response.
+                response_obj = chunk_data.get("response")
+                if not isinstance(response_obj, dict):
+                    response_obj = {}
+                chunk_ids = [
+                    value
+                    for value in (
+                        chunk_data.get("id"),
+                        chunk_data.get("response_id"),
+                        response_obj.get("id"),
+                    )
+                    if isinstance(value, str) and value
+                ]
+                if chunk_ids:
+                    response_id = chunk_ids[0]
                 if "delta" in chunk_data and "content" in chunk_data["delta"]:
                     full_response += chunk_data["delta"]["content"]
-                # Extract response_id from chunk
-                if "id" in chunk_data:
-                    response_id = chunk_data["id"]
-                elif "response_id" in chunk_data:
-                    response_id = chunk_data["response_id"]
 
                 # Check for error status. Do not forward bare Langflow error
                 # chunks — they often lack a useful message and the client would
@@ -972,6 +1031,10 @@ async def async_langflow_chat_stream(
                     usage_data = response_obj.get("usage")
             except Exception:
                 pass
+            # This await must stay outside the permissive JSON parser above.
+            # Persist/claim BEFORE yielding the first occurrence of any ID.
+            if any(session_id not in claimed_ids for session_id in chunk_ids):
+                await persist_stream_state(*chunk_ids)
             yield chunk
 
         from api.provider_validation import (
@@ -994,16 +1057,8 @@ async def async_langflow_chat_stream(
                     "error": True,
                 }
             )
-            store_id = _resolve_conversation_store_id(
-                response_id,
-                thread_id,
-                previous_loaded_from_memory=previous_loaded_from_memory,
-                mint_if_missing=True,
-            )
-            try:
-                await _persist_error_conversation(user_id, store_id, conversation_state)
-            except Exception as store_error:
-                logger.error(f"Failed to store error conversation: {store_error}")
+            turn_finished = True
+            await persist_stream_state(response_id, mint_if_missing=True)
             yield _stream_error_chunk(display_text, store_id)
             return
 
@@ -1020,20 +1075,29 @@ async def async_langflow_chat_stream(
                 assistant_message["response_data"] = {"usage": usage_data}
             conversation_state["messages"].append(assistant_message)
 
-        persist_id = _resolve_conversation_store_id(
-            response_id,
-            thread_id,
-            previous_loaded_from_memory=previous_loaded_from_memory,
-        )
-        if persist_id:
-            conversation_state["last_activity"] = datetime.now()
-            await store_conversation_thread(user_id, persist_id, conversation_state)
+        turn_finished = True
+        await persist_stream_state(response_id)
+    except (asyncio.CancelledError, GeneratorExit):
+        # Disconnects do not run the normal tail and are not provider failures.
+        # Keep exactly one partial assistant turn and propagate cancellation;
+        # never replay the prompt or synthesize a terminal event to a dead client.
+        with anyio.CancelScope(shield=True):
+            if not turn_finished and full_response:
+                conversation_state["messages"].append(
+                    {
+                        "role": "assistant",
+                        "content": full_response,
+                        "response_id": response_id,
+                        "timestamp": datetime.now(),
+                        "chunks": collected_chunks,
+                        "interrupted": True,
+                    }
+                )
             try:
-                from services.session_ownership_service import session_ownership_service
-
-                await session_ownership_service.claim_session(user_id, persist_id)
-            except Exception as e:
-                logger.warning(f"Failed to claim session ownership: {e}")
+                await persist_stream_state(response_id)
+            except Exception:
+                logger.exception("Failed to store interrupted Langflow turn")
+        raise
     except Exception as e:
         logger.error(f"Error in langflow chat stream: {e}", exc_info=True)
         from api.provider_validation import resolve_chat_stream_error_message_async
@@ -1051,17 +1115,16 @@ async def async_langflow_chat_stream(
                 "error": True,
             }
         )
-        store_id = _resolve_conversation_store_id(
-            response_id,
-            thread_id,
-            previous_loaded_from_memory=previous_loaded_from_memory,
-            mint_if_missing=True,
-        )
+        error_store_id = None
         try:
-            await _persist_error_conversation(user_id, store_id, conversation_state)
+            await persist_stream_state(response_id, mint_if_missing=True)
+            error_store_id = store_id
         except Exception as store_error:
             logger.error(f"Failed to store error conversation: {store_error}")
-        yield _stream_error_chunk(display_text, store_id)
+        yield _stream_error_chunk(display_text, error_store_id)
+    finally:
+        with anyio.CancelScope(shield=True):
+            await upstream.aclose()
 
 
 async def delete_user_conversation(user_id: str, response_id: str) -> bool:
@@ -1075,31 +1138,18 @@ async def delete_user_conversation(user_id: str, response_id: str) -> bool:
         Exception — on unexpected storage errors so callers can distinguish
                     a confirmed "not found" from a backend failure.
     """
-    deleted = False
-
-    # Delete from in-memory storage (cannot raise)
-    if user_id in active_conversations and response_id in active_conversations[user_id]:
-        del active_conversations[user_id][response_id]
-        logger.debug(f"Deleted conversation {response_id} from memory for user {user_id}")
-        deleted = True
+    from services.session_ownership_service import session_ownership_service
 
-    # Delete from persistent storage — let real errors propagate to the caller
-    conversation_deleted = await conversation_persistence.delete_conversation_thread(
-        user_id, response_id
-    )
-    if conversation_deleted:
-        logger.debug(
-            f"Deleted conversation {response_id} from persistent storage for user {user_id}"
-        )
+    session_ids = await session_ownership_service.get_conversation_sessions(user_id, response_id)
+    if not session_ids:
+        return False
+    canonical_id = session_ids[0]
+    # Revoke ALL durable aliases before removing the local index. Failures must
+    # reach the caller, not turn into a successful delete with reusable IDs.
+    await session_ownership_service.release_conversation_sessions(user_id, session_ids)
+    deleted = await conversation_persistence.delete_conversation_thread(user_id, canonical_id)
+    if canonical_id in active_conversations.get(user_id, {}):
+        del active_conversations[user_id][canonical_id]
         deleted = True
 
-    # Release session ownership (best-effort; never masks storage errors above)
-    try:
-        from services.session_ownership_service import session_ownership_service
-
-        await session_ownership_service.release_session(user_id, response_id)
-        logger.debug(f"Released session ownership for {response_id} for user {user_id}")
-    except Exception as e:
-        logger.warning(f"Failed to release session ownership: {e}")
-
     return deleted

{openrag-0.8.0.dev20 → openrag-0.8.1}/src/api/connectors.py

@@ -1073,6 +1073,7 @@ async def _expand_selected_connector_files(
 
 async def _classify_connector_duplicates(
     connector,
+    connector_type: str,
     selected_files_raw: list[Any],
     session_manager,
     user_id: str,
@@ -1081,6 +1082,14 @@ async def _classify_connector_duplicates(
     """Expand connector selections and split them into duplicate/non-duplicate files."""
     expanded_files_info = await _expand_selected_connector_files(connector, selected_files_raw)
     if not expanded_files_info:
+        # The selection named only folders that expanded to nothing, so there is
+        # nothing to compare. Counted against what the caller asked for, which
+        # separates an empty expansion from an empty request.
+        logger.info(
+            "Duplicate check found nothing to check",
+            connector_type=connector_type,
+            selected=len(selected_files_raw),
+        )
         return {
             "duplicate_names": [],
             "duplicate_files": [],
@@ -1101,6 +1110,13 @@ async def _classify_connector_duplicates(
         all_candidates.update(aliases)
 
     if not all_candidates:
+        # Files expanded but none yielded a comparable name, so the index was
+        # never queried: every file is reported new without having been checked.
+        logger.info(
+            "Duplicate check skipped: no comparable filenames",
+            connector_type=connector_type,
+            listed=len(cleaned_files),
+        )
         return {
             "duplicate_names": [],
             "duplicate_files": [],
@@ -1131,6 +1147,16 @@ async def _classify_connector_duplicates(
         else:
             non_duplicate_files.append(file_info)
 
+    # See the bucket classifier: logged so a "no dialog appeared" report can be
+    # answered from the server side.
+    logger.info(
+        "Duplicate check complete",
+        connector_type=connector_type,
+        selected=len(cleaned_files),
+        duplicates=len(duplicate_files),
+        new_files=len(non_duplicate_files),
+    )
+
     return {
         "duplicate_names": list(dict.fromkeys(duplicate_names)),
         "duplicate_files": duplicate_files,
@@ -1335,6 +1361,11 @@ async def _classify_bucket_connector_duplicates(
             break
 
     if not all_files:
+        logger.info(
+            "Duplicate check found nothing to check",
+            connector_type=connector_type,
+            buckets=bucket_filter,
+        )
         return {
             "duplicate_names": [],
             "duplicate_files": [],
@@ -1366,18 +1397,38 @@ async def _classify_bucket_connector_duplicates(
     duplicate_names: list[str] = []
     non_duplicate_files: list[dict[str, Any]] = []
     total = 0
+    already_synced = 0
     for f in all_files:
         fid = f.get("id")
         if not fid:
             continue
         total += 1
         response_file = _connector_file_response(f, cleaned_name=_cleaned_blob_filename(f))
-        if fid in existing_set or fid in name_taken_ids:
+        id_match = fid in existing_set
+        if id_match:
+            already_synced += 1
+        if id_match or fid in name_taken_ids:
             duplicate_files.append(response_file)
             duplicate_names.append(response_file["name"])
         else:
             non_duplicate_files.append(response_file)
 
+    # Both halves of the answer, so a "the dialog never appeared" report can be
+    # settled from the logs: whether the listing came back, whether the names
+    # were found in the index, and what the caller was told. Without it the only
+    # way to tell a check that found nothing from one that never ran is the
+    # browser's network tab.
+    logger.info(
+        "Duplicate check complete",
+        connector_type=connector_type,
+        buckets=bucket_filter,
+        listed=total,
+        already_synced_here=already_synced,
+        name_taken_elsewhere=len(set(name_taken_ids) - existing_set),
+        duplicates=len(duplicate_files),
+        new_files=len(non_duplicate_files),
+    )
+
     return {
         "duplicate_names": list(dict.fromkeys(duplicate_names)),
         "duplicate_files": duplicate_files,
@@ -1402,7 +1453,19 @@ async def connector_check_duplicates(
 
     selected_files_raw = body.selected_files
     if not selected_files_raw and not body.bucket_filter:
-        return JSONResponse({"duplicate_names": []})
+        # Returning an empty duplicate list here reads to the caller as "checked,
+        # found nothing", and the UI goes on to ingest without ever offering the
+        # overwrite choice — the same thing a broken check looks like. The
+        # request asked about nothing, so say that instead of answering it.
+        logger.warning(
+            "Duplicate check asked about nothing",
+            connector_type=connector_type,
+            connection_id=body.connection_id,
+        )
+        return JSONResponse(
+            {"error": "Specify selected_files or bucket_filter to check for duplicates"},
+            status_code=400,
+        )
 
     try:
         jwt_token = user.jwt_token
@@ -1458,6 +1521,7 @@ async def connector_check_duplicates(
         return JSONResponse(
             await _classify_connector_duplicates(
                 connector=connector,
+                connector_type=connector_type,
                 selected_files_raw=selected_files_raw,
                 session_manager=session_manager,
                 user_id=user.user_id,
@@ -1786,6 +1850,7 @@ async def connector_sync(
                     connector=await connector_service.get_connector(
                         working_connection.connection_id
                     ),
+                    connector_type=connector_type,
                     selected_files_raw=file_infos,
                     session_manager=session_manager,
                     user_id=user.user_id,
@@ -2341,6 +2406,12 @@ async def connector_webhook(
                 # shared=None like the other re-sync paths: no user is in the
                 # loop to express an intent, so each file keeps the sharing state
                 # it already has.
+                # allow_anonymous_delete=False for the same reason: nobody is
+                # here to authorize removing a document the whole instance can
+                # see, so a webhook replaces only what the connection's owner
+                # owns. A file indexed as shared is left as it is until someone
+                # holding the permission syncs it; no connector that delivers
+                # webhooks can index one today.
                 task_id = await connector_service.sync_specific_files(
                     connection.connection_id,
                     connection.user_id,
@@ -2348,6 +2419,7 @@ async def connector_webhook(
                     jwt_token=jwt_token,
                     replace_duplicates=_connector_sync_should_replace(connector_type),
                     shared=None,
+                    allow_anonymous_delete=False,
                 )
 
                 result = {