Merge branch 'main' of https://github.com/redis-applied-ai/redis-sre-agent

Author: abrookins

docs/ui/experimental.md

@@ -20,6 +20,16 @@ The dev server proxies `/api/v1` to `VITE_API_URL` (defaults to http://localhost
 VITE_API_URL=http://localhost:8000 npm run dev
 ```
 
+### Run UI end-to-end tests (Playwright)
+```bash
+cd ui
+npm install
+npm run e2e
+```
+
+The tests are located in `ui/e2e/`.
+
+
 ### Notes
 - Compose sets `VITE_API_URL=http://sre-agent:8000` for in‑container proxying
 - API endpoints are under `/api/v1` (e.g., `/api/v1/health`, `/api/v1/metrics`, `/api/v1/tasks`)

redis_sre_agent/core/threads.py

@@ -744,6 +744,10 @@ async def delete_thread(self, thread_id: str) -> bool:
             # Remove from indices
             await self._remove_from_thread_index(thread_id, user_id)
 
+            # Remove the hash document used by the threads search index
+            search_doc_key = f"{SRE_THREADS_INDEX}:{thread_id}"
+            await client.delete(search_doc_key)
+
             logger.info(f"Deleted thread {thread_id}")
             return True
 
@@ -887,17 +891,17 @@ async def cancel_thread(*, thread_id: str, redis_client=None) -> Dict[str, Any]:
 
 
 async def delete_thread(*, thread_id: str, redis_client=None) -> Dict[str, Any]:
-    """Permanently delete a thread."""
+    """Permanently delete a thread.
+
+    This operation is idempotent: it will succeed even if the thread has
+    already been deleted or never existed, as long as Redis is reachable.
+    """
     if redis_client is None:
         from redis_sre_agent.core.redis import get_redis_client as _get
 
         redis_client = _get()
 
     thread_manager = ThreadManager(redis_client=redis_client)
-    thread_state = await thread_manager.get_thread(thread_id)
-    if not thread_state:
-        raise ValueError(f"Thread {thread_id} not found")
-
     success = await thread_manager.delete_thread(thread_id)
     if not success:
         raise RuntimeError(f"Failed to delete thread {thread_id}")

tests/integration/core/test_threads_delete_integration.py

@@ -0,0 +1,110 @@
+"""Integration test for thread deletion and Redis data layout.
+
+This test exercises the new Threads API against a real Redis instance
+(provided by the testcontainers-backed redis_container fixture).
+It creates a thread via the HTTP API, attempts to delete it, and inspects
+thread-related keys (including the search-index hash) before and after
+deletion.
+"""
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from redis_sre_agent.core.keys import RedisKeys
+from redis_sre_agent.core.redis import SRE_THREADS_INDEX
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_thread_delete_integration(async_redis_client, redis_container):
+    """Create a thread via API, delete it, and inspect Redis keys.
+
+    This exercises the real delete path and asserts that it cleans up both
+    the per-thread keys and the hash document backing the threads search
+    index.
+    """
+    if not redis_container:
+        pytest.skip("Integration tests not enabled")
+
+    # Import the real FastAPI app only after redis_container has configured
+    # REDIS_URL and created indices in the test Redis.
+    from redis_sre_agent.api.app import app
+
+    # ------------------------------------------------------------------
+    # 1. Create a thread via the Threads API
+    # ------------------------------------------------------------------
+    create_payload = {
+        "user_id": "test-user",
+        "session_id": "test-session",
+        "subject": "Delete me",
+        "messages": [{"role": "user", "content": "Please investigate delete behaviour."}],
+    }
+
+    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
+        create_resp = await client.post("/api/v1/threads", json=create_payload)
+
+    assert create_resp.status_code == 201
+    create_body = create_resp.json()
+    thread_id = create_body["thread_id"]
+
+    # ------------------------------------------------------------------
+    # 2. Inspect Redis keys before deletion
+    # ------------------------------------------------------------------
+    thread_key_pattern = f"sre:thread:{thread_id}:*"
+
+    before_keys = set()
+    cursor = 0
+    while True:
+        cursor, batch = await async_redis_client.scan(cursor=cursor, match=thread_key_pattern)
+        if batch:
+            before_keys.update(batch)
+        if cursor == 0:
+            break
+
+    before_keys_str = {
+        k.decode("utf-8") if isinstance(k, (bytes, bytearray)) else str(k) for k in before_keys
+    }
+
+    # We expect at least the metadata key to be present for a fresh thread.
+    assert RedisKeys.thread_metadata(thread_id) in before_keys_str
+
+    search_hash_key = f"{SRE_THREADS_INDEX}:{thread_id}"
+    search_hash_exists_before = bool(await async_redis_client.exists(search_hash_key))
+    # The search hash is written by ThreadManager._upsert_thread_search_doc during creation.
+    assert search_hash_exists_before
+
+    # ------------------------------------------------------------------
+    # 3. Attempt to delete the thread via the API
+    # ------------------------------------------------------------------
+    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
+        delete_resp = await client.delete(f"/api/v1/threads/{thread_id}")
+        delete_resp_second = await client.delete(f"/api/v1/threads/{thread_id}")
+
+    # Delete should now be idempotent and always return 204 even if the
+    # underlying keys have already been removed.
+    assert delete_resp.status_code == 204
+    assert delete_resp_second.status_code == 204
+
+    # ------------------------------------------------------------------
+    # 4. Inspect Redis keys after deletion
+    # ------------------------------------------------------------------
+    after_keys = set()
+    cursor = 0
+    while True:
+        cursor, batch = await async_redis_client.scan(cursor=cursor, match=thread_key_pattern)
+        if batch:
+            after_keys.update(batch)
+        if cursor == 0:
+            break
+
+    after_keys_str = {
+        k.decode("utf-8") if isinstance(k, (bytes, bytearray)) else str(k) for k in after_keys
+    }
+
+    # The per-thread metadata key is removed by the existing delete path.
+    assert RedisKeys.thread_metadata(thread_id) not in after_keys_str
+
+    # After deletion, the hash that backs the threads search index should also
+    # be removed so the thread no longer appears in search results.
+    search_hash_exists_after = bool(await async_redis_client.exists(search_hash_key))
+    assert not search_hash_exists_after