Python: [BREAKING] cleanup of thread API and serialization (#893)

* cleanup of threads and serialization * fix for sliding window * fix redis test * updated from comments * updated context provider and threads * updated lock * add asyncio default * fix redis tests * fix tests * fix tests * renamed to invoking * fixed tests * fix for instructions
2026-06-16 21:04:09 +08:00 · 2025-09-29 18:22:34 +02:00
parent bf5931932e
commit 10d10364a9
52 changed files with 1642 additions and 1411 deletions
@@ -22,7 +22,7 @@ class RedisStoreState(AFBaseModel):


 class RedisChatMessageStore:
-    """Redis-backed implementation of ChatMessageStore using Redis Lists.
+    """Redis-backed implementation of ChatMessageStoreProtocol using Redis Lists.

    This implementation provides persistent, thread-safe chat message storage using Redis Lists.
    Messages are stored as JSON-serialized strings in chronological order, with each conversation
@@ -153,9 +153,9 @@ class RedisChatMessageStore:
            await pipe.execute()

    async def add_messages(self, messages: Sequence[ChatMessage]) -> None:
-        """Add messages to the Redis store (ChatMessageStore protocol method).
+        """Add messages to the Redis store (ChatMessageStoreProtocol protocol method).

-        This method implements the required ChatMessageStore protocol for adding messages.
+        This method implements the required ChatMessageStoreProtocol protocol for adding messages.
        Messages are appended to the Redis list in chronological order, with automatic
        trimming if message limits are configured.

@@ -190,9 +190,9 @@ class RedisChatMessageStore:
                await self._redis_client.ltrim(self.redis_key, -self.max_messages, -1)  # type: ignore[misc]

    async def list_messages(self) -> list[ChatMessage]:
-        """Get all messages from the store in chronological order (ChatMessageStore protocol method).
+        """Get all messages from the store in chronological order (ChatMessageStoreProtocol protocol method).

-        This method implements the required ChatMessageStore protocol for retrieving messages.
+        This method implements the required ChatMessageStoreProtocol protocol for retrieving messages.
        Returns all messages stored in Redis, ordered from oldest (index 0) to newest (index -1).

        Returns:
@@ -220,10 +220,10 @@ class RedisChatMessageStore:

        return messages

-    async def serialize_state(self, **kwargs: Any) -> Any:
-        """Serialize the current store state for persistence (ChatMessageStore protocol method).
+    async def serialize(self, **kwargs: Any) -> Any:
+        """Serialize the current store state for persistence (ChatMessageStoreProtocol protocol method).

-        This method implements the required ChatMessageStore protocol for state serialization.
+        This method implements the required ChatMessageStoreProtocol protocol for state serialization.
        Captures the Redis connection configuration and thread information needed to
        reconstruct the store and reconnect to the same conversation data.

@@ -243,10 +243,43 @@ class RedisChatMessageStore:
        )
        return state.model_dump(**kwargs)

-    async def deserialize_state(self, serialized_store_state: Any, **kwargs: Any) -> None:
-        """Deserialize state data into this store instance (ChatMessageStore protocol method).
+    @classmethod
+    async def deserialize(cls, serialized_store_state: Any, **kwargs: Any) -> RedisChatMessageStore:
+        """Deserialize state data into a new store instance (ChatMessageStoreProtocol protocol method).

-        This method implements the required ChatMessageStore protocol for state deserialization.
+        This method implements the required ChatMessageStoreProtocol protocol for state deserialization.
+        Creates a new RedisChatMessageStore instance from previously serialized data,
+        allowing the store to reconnect to the same conversation data in Redis.
+
+        Args:
+            serialized_store_state: Previously serialized state data from serialize_state().
+                                   Should be a dictionary with thread_id, redis_url, etc.
+            **kwargs: Additional arguments passed to Pydantic model validation.
+
+        Returns:
+            A new RedisChatMessageStore instance configured from the serialized state.
+
+        Raises:
+            ValueError: If required fields are missing or invalid in the serialized state.
+        """
+        if not serialized_store_state:
+            raise ValueError("serialized_store_state is required for deserialization")
+
+        # Validate and parse the serialized state using Pydantic
+        state = RedisStoreState.model_validate(serialized_store_state, **kwargs)
+
+        # Create and return a new store instance with the deserialized configuration
+        return cls(
+            redis_url=state.redis_url,
+            thread_id=state.thread_id,
+            key_prefix=state.key_prefix,
+            max_messages=state.max_messages,
+        )
+
+    async def update_from_state(self, serialized_store_state: Any, **kwargs: Any) -> None:
+        """Deserialize state data into this store instance (ChatMessageStoreProtocol protocol method).
+
+        This method implements the required ChatMessageStoreProtocol protocol for state deserialization.
        Restores the store configuration from previously serialized data, allowing the store
        to reconnect to the same conversation data in Redis.

@@ -1,32 +1,34 @@
 # Copyright (c) Microsoft. All rights reserved.

-from __future__ import annotations
-
+import json
 import sys
 from collections.abc import MutableSequence, Sequence
 from functools import reduce
 from operator import and_
 from typing import Any, Literal, cast

-from agent_framework import ChatMessage, Context, ContextProvider, Role, TextContent
+import numpy as np
+from agent_framework import ChatMessage, Context, ContextProvider, Role
 from agent_framework.exceptions import (
+    AgentException,
    ServiceInitializationError,
    ServiceInvalidRequestError,
 )
+from redisvl.index import AsyncSearchIndex
+from redisvl.query import FilterQuery, HybridQuery, TextQuery
+from redisvl.query.filter import FilterExpression, Tag
+from redisvl.utils.token_escaper import TokenEscaper
+from redisvl.utils.vectorize import BaseVectorizer

 if sys.version_info >= (3, 11):
    from typing import Self  # pragma: no cover
 else:
    from typing_extensions import Self  # pragma: no cover

-import json
-
-import numpy as np
-from redisvl.index import AsyncSearchIndex
-from redisvl.query import FilterQuery, HybridQuery, TextQuery
-from redisvl.query.filter import FilterExpression, Tag
-from redisvl.utils.token_escaper import TokenEscaper
-from redisvl.utils.vectorize import BaseVectorizer
+if sys.version_info >= (3, 12):
+    from typing import override  # type: ignore # pragma: no cover
+else:
+    from typing_extensions import override  # type: ignore[import] # pragma: no cover


 class RedisProvider(ContextProvider):
@@ -36,41 +38,73 @@ class RedisProvider(ContextProvider):
    Uses full-text or optional hybrid vector search to ground model responses.
    """

-    # Connection and indexing
-    redis_url: str = "redis://localhost:6379"
-    index_name: str = "context"
-    prefix: str = "context"
+    def __init__(
+        self,
+        redis_url: str = "redis://localhost:6379",
+        index_name: str = "context",
+        prefix: str = "context",
+        # Redis vectorizer configuration (optional, injected by client)
+        redis_vectorizer: BaseVectorizer | None = None,
+        vector_field_name: str | None = None,
+        vector_algorithm: Literal["flat", "hnsw"] | None = None,
+        vector_distance_metric: Literal["cosine", "ip", "l2"] | None = None,
+        # Partition fields (indexed for filtering)
+        application_id: str | None = None,
+        agent_id: str | None = None,
+        user_id: str | None = None,
+        thread_id: str | None = None,
+        scope_to_per_operation_thread_id: bool = False,
+        # Prompt and runtime
+        context_prompt: str = ContextProvider.DEFAULT_CONTEXT_PROMPT,
+        redis_index: Any = None,
+        overwrite_index: bool = False,
+    ):
+        """Create a Redis Context Provider.

-    # Redis vectorizer configuration (optional, injected by client)
-    redis_vectorizer: BaseVectorizer | None = None
-    vector_field_name: str | None = None
-    vector_algorithm: Literal["flat", "hnsw"] | None = None
-    vector_distance_metric: Literal["cosine", "ip", "l2"] | None = None
+        Args:
+            redis_url: The Redis server URL.
+            index_name: The name of the Redis index.
+            prefix: The prefix for all keys in the Redis database.
+            redis_vectorizer: The vectorizer to use for Redis.
+            vector_field_name: The name of the vector field in Redis.
+            vector_algorithm: The algorithm to use for vector search.
+            vector_distance_metric: The distance metric to use for vector search.
+            application_id: The application ID to scope the context.
+            agent_id: The agent ID to scope the context.
+            user_id: The user ID to scope the context.
+            thread_id: The thread ID to scope the context.
+            scope_to_per_operation_thread_id: Whether to scope to the per-operation thread ID.
+            context_prompt: The context prompt to use for the provider.
+            redis_index: The Redis index to use for the provider.
+            overwrite_index: Whether to overwrite the existing Redis index.

-    # Partition fields (indexed for filtering)
-    application_id: str | None = None
-    agent_id: str | None = None
-    user_id: str | None = None
-    thread_id: str | None = None
-    scope_to_per_operation_thread_id: bool = False
-
-    # Prompt and runtime
-    context_prompt: str = ContextProvider.DEFAULT_CONTEXT_PROMPT
-    redis_index: Any = None
-    overwrite_index: bool = False
-    _per_operation_thread_id: str | None = None
-    _token_escaper: TokenEscaper = TokenEscaper()
-    _conversation_id: str | None = None
-    _index_initialized: bool = False
-    _schema_dict: dict[str, Any] | None = None
-
-    def model_post_init(self, __context: Any) -> None:
-        """Post-initialization hook to set up computed fields after Pydantic initialization.
-
-        This is called automatically by Pydantic after the model is initialized.
        """
-        # Create Redis index using the cached schema_dict property
-        self.redis_index = AsyncSearchIndex.from_dict(self.schema_dict, redis_url=self.redis_url, validate_on_load=True)
+        self.redis_url = redis_url
+        self.index_name = index_name
+        self.prefix = prefix
+        if redis_vectorizer is not None and not isinstance(redis_vectorizer, BaseVectorizer):
+            raise AgentException(
+                f"The redis vectorizer is not a valid type, got: {type(redis_vectorizer)}, expected: BaseVectorizer."
+            )
+        self.redis_vectorizer = redis_vectorizer
+        self.vector_field_name = vector_field_name
+        self.vector_algorithm: Literal["flat", "hnsw"] | None = vector_algorithm
+        self.vector_distance_metric: Literal["cosine", "ip", "l2"] | None = vector_distance_metric
+        self.application_id = application_id
+        self.agent_id = agent_id
+        self.user_id = user_id
+        self.thread_id = thread_id
+        self.scope_to_per_operation_thread_id = scope_to_per_operation_thread_id
+        self.context_prompt = context_prompt
+        self.overwrite_index = overwrite_index
+        self._per_operation_thread_id: str | None = None
+        self._token_escaper: TokenEscaper = TokenEscaper()
+        self._conversation_id: str | None = None
+        self._index_initialized: bool = False
+        self._schema_dict: dict[str, Any] | None = None
+        self.redis_index = redis_index or AsyncSearchIndex.from_dict(
+            self.schema_dict, redis_url=self.redis_url, validate_on_load=True
+        )

    @property
    def schema_dict(self) -> dict[str, Any]:
@@ -429,6 +463,7 @@ class RedisProvider(ContextProvider):
        """
        return self._per_operation_thread_id if self.scope_to_per_operation_thread_id else self.thread_id

+    @override
    async def thread_created(self, thread_id: str | None) -> None:
        """Called when a new thread is created.

@@ -442,20 +477,27 @@ class RedisProvider(ContextProvider):
        # Track current conversation id (Agent passes conversation_id here)
        self._conversation_id = thread_id or self._conversation_id

-    async def messages_adding(self, thread_id: str | None, new_messages: ChatMessage | Sequence[ChatMessage]) -> None:
-        """Called when a new message is being added to the thread.
-
-        Validates scope, normalizes allowed roles, and persists messages to Redis via add().
-
-        Args:
-            thread_id: The ID of the thread or None.
-            new_messages: New messages to add.
-        """
+    @override
+    async def invoked(
+        self,
+        request_messages: ChatMessage | Sequence[ChatMessage],
+        response_messages: ChatMessage | Sequence[ChatMessage] | None = None,
+        invoke_exception: Exception | None = None,
+        **kwargs: Any,
+    ) -> None:
        self._validate_filters()
-        self._validate_per_operation_thread_id(thread_id)
-        self._per_operation_thread_id = self._per_operation_thread_id or thread_id

-        messages_list = [new_messages] if isinstance(new_messages, ChatMessage) else list(new_messages)
+        request_messages_list = (
+            [request_messages] if isinstance(request_messages, ChatMessage) else list(request_messages)
+        )
+        response_messages_list = (
+            [response_messages]
+            if isinstance(response_messages, ChatMessage)
+            else list(response_messages)
+            if response_messages
+            else []
+        )
+        messages_list = [*request_messages_list, *response_messages_list]

        messages: list[dict[str, Any]] = []
        for message in messages_list:
@@ -475,7 +517,8 @@ class RedisProvider(ContextProvider):
        if messages:
            await self._add(data=messages)

-    async def model_invoking(self, messages: ChatMessage | MutableSequence[ChatMessage]) -> Context:
+    @override
+    async def invoking(self, messages: ChatMessage | MutableSequence[ChatMessage], **kwargs: Any) -> Context:
        """Called before invoking the model to provide scoped context.

        Concatenates recent messages into a query, fetches matching memories from Redis.
@@ -483,6 +526,7 @@ class RedisProvider(ContextProvider):

        Args:
            messages: List of new messages in the thread.
+            kwargs: not used at present at present.

        Returns:
            Context: Context object containing instructions with memories.
@@ -495,8 +539,12 @@ class RedisProvider(ContextProvider):
        line_separated_memories = "\n".join(
            str(memory.get("content", "")) for memory in memories if memory.get("content")
        )
-        content = TextContent(f"{self.context_prompt}\n{line_separated_memories}") if line_separated_memories else None
-        return Context(contents=[content] if content else None)
+
+        return Context(
+            messages=[ChatMessage(role="user", text=f"{self.context_prompt}\n{line_separated_memories}")]
+            if line_separated_memories
+            else None
+        )

    async def __aenter__(self) -> Self:
        """Async context manager entry.
@@ -239,7 +239,7 @@ class TestRedisChatMessageStore:

    async def test_serialize_state(self, redis_store):
        """Test state serialization."""
-        state = await redis_store.serialize_state()
+        state = await redis_store.serialize()

        expected_state = {
            "thread_id": "test_thread_123",
@@ -259,7 +259,7 @@ class TestRedisChatMessageStore:
            "max_messages": 50,
        }

-        await redis_store.deserialize_state(serialized_state)
+        await redis_store.update_from_state(serialized_state)

        assert redis_store.thread_id == "restored_thread_456"
        assert redis_store.redis_url == "redis://localhost:6380"
@@ -270,7 +270,7 @@ class TestRedisChatMessageStore:
        """Test deserializing empty state doesn't change anything."""
        original_thread_id = redis_store.thread_id

-        await redis_store.deserialize_state(None)
+        await redis_store.update_from_state(None)

        assert redis_store.thread_id == original_thread_id

@@ -6,8 +6,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
 import numpy as np
 import pytest
 from agent_framework import ChatMessage, Role
-from agent_framework.exceptions import ServiceInitializationError
-from pydantic import ValidationError
+from agent_framework.exceptions import AgentException, ServiceInitializationError
 from redisvl.utils.vectorize import CustomTextVectorizer

 from agent_framework_redis import RedisProvider
@@ -121,21 +120,18 @@ class TestRedisProviderMessages:
            ChatMessage(role=Role.SYSTEM, text="You are a helpful assistant"),
        ]

-    @pytest.mark.asyncio
    # Writes require at least one scoping filter to avoid unbounded operations
    async def test_messages_adding_requires_filters(self, patch_index_from_dict):  # noqa: ARG002
        provider = RedisProvider()
        with pytest.raises(ServiceInitializationError):
-            await provider.messages_adding("thread123", ChatMessage(role=Role.USER, text="Hello"))
+            await provider.invoked("thread123", ChatMessage(role=Role.USER, text="Hello"))

-    @pytest.mark.asyncio
    # Captures the per-operation thread id when provided
    async def test_thread_created_sets_per_operation_id(self, patch_index_from_dict):  # noqa: ARG002
        provider = RedisProvider(user_id="u1")
        await provider.thread_created("t1")
        assert provider._per_operation_thread_id == "t1"

-    @pytest.mark.asyncio
    # Enforces single-thread usage when scope_to_per_operation_thread_id is True
    async def test_thread_created_conflict_when_scoped(self, patch_index_from_dict):  # noqa: ARG002
        provider = RedisProvider(user_id="u1", scope_to_per_operation_thread_id=True)
@@ -144,7 +140,6 @@ class TestRedisProviderMessages:
            await provider.thread_created("t2")
        assert "only be used with one thread" in str(exc.value)

-    @pytest.mark.asyncio
    # Aggregates all results from the async paginator into a flat list
    async def test_search_all_paginates(self, mock_index: AsyncMock, patch_index_from_dict):  # noqa: ARG002
        async def gen(_q, page_size: int = 200):  # noqa: ARG001, ANN001
@@ -158,14 +153,12 @@ class TestRedisProviderMessages:


 class TestRedisProviderModelInvoking:
-    @pytest.mark.asyncio
    # Reads require at least one scoping filter to avoid unbounded operations
    async def test_model_invoking_requires_filters(self, patch_index_from_dict):  # noqa: ARG002
        provider = RedisProvider()
        with pytest.raises(ServiceInitializationError):
-            await provider.model_invoking(ChatMessage(role=Role.USER, text="Hi"))
+            await provider.invoking(ChatMessage(role=Role.USER, text="Hi"))

-    @pytest.mark.asyncio
    # Ensures text-only search path is used and context is composed from hits
    async def test_textquery_path_and_context_contents(
        self, mock_index: AsyncMock, patch_index_from_dict, patch_queries
@@ -175,7 +168,7 @@ class TestRedisProviderModelInvoking:
        provider = RedisProvider(user_id="u1")

        # Act
-        ctx = await provider.model_invoking([ChatMessage(role=Role.USER, text="q1")])
+        ctx = await provider.invoking([ChatMessage(role=Role.USER, text="q1")])

        # Assert: TextQuery used (not HybridQuery), filter_expression included
        assert patch_queries["TextQuery"].call_count == 1
@@ -187,27 +180,25 @@ class TestRedisProviderModelInvoking:
        assert "filter_expression" in kwargs

        # Context contains memories joined after the default prompt
-        assert ctx.contents is not None and len(ctx.contents) == 1
-        text = ctx.contents[0].text
+        assert ctx.messages is not None and len(ctx.messages) == 1
+        text = ctx.messages[0].text
        assert text.endswith("A\nB")

-    @pytest.mark.asyncio
    # When no results are returned, Context should have no contents
    async def test_model_invoking_empty_results_returns_empty_context(
        self, mock_index: AsyncMock, patch_index_from_dict, patch_queries
    ):  # noqa: ARG002
        mock_index.query = AsyncMock(return_value=[])
        provider = RedisProvider(user_id="u1")
-        ctx = await provider.model_invoking([ChatMessage(role=Role.USER, text="any")])
-        assert ctx.contents is None
+        ctx = await provider.invoking([ChatMessage(role=Role.USER, text="any")])
+        assert ctx.messages == []

-    @pytest.mark.asyncio
    # Ensures hybrid vector-text search is used when a vectorizer and vector field are configured
    async def test_hybridquery_path_with_vectorizer(self, mock_index: AsyncMock, patch_index_from_dict, patch_queries):  # noqa: ARG002
        mock_index.query = AsyncMock(return_value=[{"content": "Hit"}])
        provider = RedisProvider(user_id="u1", redis_vectorizer=CUSTOM_VECTORIZER, vector_field_name="vec")

-        ctx = await provider.model_invoking([ChatMessage(role=Role.USER, text="hello")])
+        ctx = await provider.invoking([ChatMessage(role=Role.USER, text="hello")])

        # Assert: HybridQuery used with vector and vector field
        assert patch_queries["HybridQuery"].call_count == 1
@@ -220,18 +211,16 @@ class TestRedisProviderModelInvoking:
        assert "filter_expression" in k

        # Context assembled from returned memories
-        assert ctx.contents and "Hit" in ctx.contents[0].text
+        assert ctx.messages and "Hit" in ctx.messages[0].text


 class TestRedisProviderContextManager:
-    @pytest.mark.asyncio
    # Verifies async context manager returns self for chaining
    async def test_async_context_manager_returns_self(self, patch_index_from_dict):  # noqa: ARG002
        provider = RedisProvider(user_id="u1")
        async with provider as ctx:
            assert ctx is provider

-    @pytest.mark.asyncio
    # Exit should be a no-op and not raise
    async def test_aexit_noop(self, patch_index_from_dict):  # noqa: ARG002
        provider = RedisProvider(user_id="u1")
@@ -239,7 +228,6 @@ class TestRedisProviderContextManager:


 class TestMessagesAddingBehavior:
-    @pytest.mark.asyncio
    # Adds messages while injecting partition defaults and preserving allowed roles
    async def test_messages_adding_adds_partition_defaults_and_roles(
        self, mock_index: AsyncMock, patch_index_from_dict
@@ -257,7 +245,7 @@ class TestMessagesAddingBehavior:
            ChatMessage(role=Role.SYSTEM, text="s"),
        ]

-        await provider.messages_adding("t1", msgs)
+        await provider.invoked(msgs)

        # Ensure load invoked with shaped docs containing defaults
        assert mock_index.load.await_count == 1
@@ -270,9 +258,7 @@ class TestMessagesAddingBehavior:
            assert d["application_id"] == "app"
            assert d["agent_id"] == "agent"
            assert d["user_id"] == "u1"
-            assert d["thread_id"] == "t1"  # scoped via per-operation thread id

-    @pytest.mark.asyncio
    # Skips blank text and disallowed roles (e.g., TOOL) when adding messages
    async def test_messages_adding_ignores_blank_and_disallowed_roles(
        self, mock_index: AsyncMock, patch_index_from_dict
@@ -282,37 +268,34 @@ class TestMessagesAddingBehavior:
            ChatMessage(role=Role.USER, text="   "),
            ChatMessage(role=Role.TOOL, text="tool output"),
        ]
-        await provider.messages_adding("tid", msgs)
+        await provider.invoked(msgs)
        # No valid messages -> no load
        assert mock_index.load.await_count == 0


 class TestIndexCreationPublicCalls:
-    @pytest.mark.asyncio
    # Ensures index is created only once when drop=True on first public write call
    async def test_messages_adding_triggers_index_create_once_when_drop_true(
        self, mock_index: AsyncMock, patch_index_from_dict
    ):  # noqa: ARG002
-        provider = RedisProvider(user_id="u1", drop_redis_index=True)
-        await provider.messages_adding("t1", ChatMessage(role=Role.USER, text="m1"))
-        await provider.messages_adding("t1", ChatMessage(role=Role.USER, text="m2"))
+        provider = RedisProvider(user_id="u1")
+        await provider.invoked(ChatMessage(role=Role.USER, text="m1"))
+        await provider.invoked(ChatMessage(role=Role.USER, text="m2"))
        # create only on first call
        assert mock_index.create.await_count == 1

-    @pytest.mark.asyncio
    # Ensures index is created when drop=False and the index does not exist on first read
    async def test_model_invoking_triggers_create_when_drop_false_and_not_exists(
        self, mock_index: AsyncMock, patch_index_from_dict
    ):  # noqa: ARG002
        mock_index.exists = AsyncMock(return_value=False)
-        provider = RedisProvider(user_id="u1", drop_redis_index=False)
+        provider = RedisProvider(user_id="u1")
        mock_index.query = AsyncMock(return_value=[{"content": "C"}])
-        await provider.model_invoking([ChatMessage(role=Role.USER, text="q")])
+        await provider.invoking([ChatMessage(role=Role.USER, text="q")])
        assert mock_index.create.await_count == 1


 class TestThreadCreatedAdditional:
-    @pytest.mark.asyncio
    # Allows None or same thread id repeatedly; different id raises when scoped
    async def test_thread_created_allows_none_and_same_id(self, patch_index_from_dict):  # noqa: ARG002
        provider = RedisProvider(user_id="u1", scope_to_per_operation_thread_id=True)
@@ -327,8 +310,7 @@ class TestThreadCreatedAdditional:


 class TestVectorPopulation:
-    @pytest.mark.asyncio
-    # When vectorizer configured, messages_adding should embed content and populate the vector field
+    # When vectorizer configured, invoked should embed content and populate the vector field
    async def test_messages_adding_populates_vector_field_when_vectorizer_present(
        self, mock_index: AsyncMock, patch_index_from_dict
    ):  # noqa: ARG002
@@ -339,7 +321,7 @@ class TestVectorPopulation:
            vector_field_name="vec",
        )

-        await provider.messages_adding("t1", ChatMessage(role=Role.USER, text="hello"))
+        await provider.invoked(ChatMessage(role=Role.USER, text="hello"))
        assert mock_index.load.await_count == 1
        (loaded_args, _kwargs) = mock_index.load.call_args
        docs = loaded_args[0]
@@ -365,12 +347,11 @@ class TestRedisProviderSchemaVectors:
        class DummyVectorizer:
            pass

-        with pytest.raises(ValidationError):
+        with pytest.raises(AgentException):
            RedisProvider(user_id="u1", redis_vectorizer=DummyVectorizer(), vector_field_name="vec")


 class TestEnsureIndex:
-    @pytest.mark.asyncio
    # Creates index once and marks _index_initialized to prevent duplicate calls
    async def test_ensure_index_creates_once(self, mock_index: AsyncMock, patch_index_from_dict):  # noqa: ARG002
        # Mock index doesn't exist, so it will be created
@@ -386,7 +367,6 @@ class TestEnsureIndex:
        await provider._ensure_index()
        assert mock_index.create.await_count == 1

-    @pytest.mark.asyncio
    # Creates index with overwrite=True when overwrite_index=True
    async def test_ensure_index_with_overwrite_true(self, mock_index: AsyncMock, patch_index_from_dict):  # noqa: ARG002
        mock_index.exists = AsyncMock(return_value=True)
@@ -397,7 +377,6 @@ class TestEnsureIndex:
        # Should call create with overwrite=True, drop=False
        mock_index.create.assert_called_once_with(overwrite=True, drop=False)

-    @pytest.mark.asyncio
    # Creates index with overwrite=False when index doesn't exist
    async def test_ensure_index_create_if_missing(self, mock_index: AsyncMock, patch_index_from_dict):  # noqa: ARG002
        mock_index.exists = AsyncMock(return_value=False)
@@ -408,7 +387,6 @@ class TestEnsureIndex:
        # Should call create with overwrite=False, drop=False
        mock_index.create.assert_called_once_with(overwrite=False, drop=False)

-    @pytest.mark.asyncio
    # Validates schema compatibility when index exists and overwrite=False
    async def test_ensure_index_schema_validation_success(self, mock_index: AsyncMock, patch_index_from_dict):  # noqa: ARG002
        mock_index.exists = AsyncMock(return_value=True)
@@ -424,7 +402,6 @@ class TestEnsureIndex:
        patch_index_from_dict.from_existing.assert_called_once_with("context", redis_url="redis://localhost:6379")
        mock_index.create.assert_called_once_with(overwrite=False, drop=False)

-    @pytest.mark.asyncio
    # Raises ServiceInitializationError when schemas don't match
    async def test_ensure_index_schema_validation_failure(self, mock_index: AsyncMock, patch_index_from_dict):  # noqa: ARG002
        mock_index.exists = AsyncMock(return_value=True)