Skip to content

A programming framework for agentic AI

Fix Redis Deserialization Error (#6952)

Ben Constable29a84e293c27
diff --git a/python/packages/autogen-ext/src/autogen_ext/models/cache/_chat_completion_cache.py b/python/packages/autogen-ext/src/autogen_ext/models/cache/_chat_completion_cache.py
index 07e3d89e8..279cffb81 100644
--- a/python/packages/autogen-ext/src/autogen_ext/models/cache/_chat_completion_cache.py
+++ b/python/packages/autogen-ext/src/autogen_ext/models/cache/_chat_completion_cache.py
@@ -1,7 +1,7 @@
import hashlib
import json
import warnings
-from typing import Any, AsyncGenerator, List, Literal, Mapping, Optional, Sequence, Union, cast
+from typing import Any, AsyncGenerator, List, Literal, Mapping, Optional, Sequence, Union
from autogen_core import CacheStore, CancellationToken, Component, ComponentModel, InMemoryStore
from autogen_core.models import (
@@ -13,7 +13,7 @@ from autogen_core.models import (
RequestUsage,
)
from autogen_core.tools import Tool, ToolSchema
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
from typing_extensions import Self
CHAT_CACHE_VALUE_TYPE = Union[CreateResult, List[Union[str, CreateResult]]]
@@ -126,8 +126,29 @@ class ChatCompletionCache(ChatCompletionClient, Component[ChatCompletionCacheCon
serialized_data = json.dumps(data, sort_keys=True)
cache_key = hashlib.sha256(serialized_data.encode()).hexdigest()
- cached_result = cast(Optional[CreateResult], self.store.get(cache_key))
+ cached_result = self.store.get(cache_key)
if cached_result is not None:
+ # Handle case where cache store returns dict instead of CreateResult (e.g., Redis)
+ if isinstance(cached_result, dict):
+ try:
+ cached_result = CreateResult.model_validate(cached_result)
+ except ValidationError:
+ # If reconstruction fails, treat as cache miss
+ return None, cache_key
+ elif isinstance(cached_result, list):
+ # Handle streaming results - reconstruct CreateResult instances from dicts
+ try:
+ reconstructed_list: List[Union[str, CreateResult]] = []
+ for item in cached_result:
+ if isinstance(item, dict):
+ reconstructed_list.append(CreateResult.model_validate(item))
+ else:
+ reconstructed_list.append(item)
+ cached_result = reconstructed_list
+ except ValidationError:
+ # If reconstruction fails, treat as cache miss
+ return None, cache_key
+ # If it's already the right type (CreateResult or list), return as-is
return cached_result, cache_key
return None, cache_key
diff --git a/python/packages/autogen-ext/tests/models/test_chat_completion_cache.py b/python/packages/autogen-ext/tests/models/test_chat_completion_cache.py
index adf2da476..3a125307a 100644
--- a/python/packages/autogen-ext/tests/models/test_chat_completion_cache.py
+++ b/python/packages/autogen-ext/tests/models/test_chat_completion_cache.py
@@ -1,15 +1,17 @@
import copy
-from typing import List, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
import pytest
+from autogen_core import CacheStore
from autogen_core.models import (
ChatCompletionClient,
CreateResult,
LLMMessage,
+ RequestUsage,
SystemMessage,
UserMessage,
)
-from autogen_ext.models.cache import ChatCompletionCache
+from autogen_ext.models.cache import CHAT_CACHE_VALUE_TYPE, ChatCompletionCache
from autogen_ext.models.replay import ReplayChatCompletionClient
from pydantic import BaseModel
@@ -184,3 +186,297 @@ async def test_cache_create_stream() -> None:
# cached_client_config = cached_client.dump_component()
# loaded_client = ChatCompletionCache.load_component(cached_client_config)
# assert loaded_client.client == cached_client.client
+
+
+class MockCacheStore(CacheStore[CHAT_CACHE_VALUE_TYPE]):
+ """Mock cache store for testing deserialization scenarios."""
+
+ def __init__(self, return_value: Optional[CHAT_CACHE_VALUE_TYPE] = None) -> None:
+ self._return_value = return_value
+ self._storage: Dict[str, CHAT_CACHE_VALUE_TYPE] = {}
+
+ def get(self, key: str, default: Optional[CHAT_CACHE_VALUE_TYPE] = None) -> Optional[CHAT_CACHE_VALUE_TYPE]:
+ return self._return_value # type: ignore
+
+ def set(self, key: str, value: CHAT_CACHE_VALUE_TYPE) -> None:
+ self._storage[key] = value
+
+ def _to_config(self) -> BaseModel:
+ """Dummy implementation for testing."""
+ return BaseModel()
+
+ @classmethod
+ def _from_config(cls, _config: BaseModel) -> "MockCacheStore":
+ """Dummy implementation for testing."""
+ return cls()
+
+
+def test_check_cache_redis_dict_deserialization_success() -> None:
+ """Test _check_cache when Redis cache returns a dict that can be deserialized to CreateResult.
+ This tests the core Redis deserialization fix where Redis returns serialized Pydantic
+ models as dictionaries instead of the original objects.
+ """
+ _, prompts, system_prompt, replay_client, _ = get_test_data()
+
+ # Create a CreateResult instance (simulating deserialized Redis data)
+ create_result = CreateResult(
+ content="test response from redis",
+ usage=RequestUsage(prompt_tokens=15, completion_tokens=8),
+ cached=False,
+ finish_reason="stop",
+ )
+
+ # Mock cache store that returns a CreateResult (simulating Redis behavior)
+ mock_store = MockCacheStore(return_value=create_result)
+ cached_client = ChatCompletionCache(replay_client, mock_store)
+
+ # Test _check_cache method directly using proper test data
+ messages = [system_prompt, UserMessage(content=prompts[0], source="user")]
+ cached_result, cache_key = cached_client._check_cache(messages, [], None, {}) # type: ignore
+
+ assert cached_result is not None
+ assert isinstance(cached_result, CreateResult)
+ assert cached_result.content == "test response from redis"
+ assert cache_key is not None
+
+
+def test_check_cache_redis_dict_deserialization_failure() -> None:
+ """Test _check_cache gracefully handles corrupted Redis data.
+ This ensures the system degrades gracefully when Redis returns corrupted
+ or invalid data that cannot be deserialized back to CreateResult.
+ """
+ _, prompts, system_prompt, replay_client, _ = get_test_data()
+
+ # Mock cache store that returns None (simulating deserialization failure)
+ mock_store = MockCacheStore(return_value=None)
+ cached_client = ChatCompletionCache(replay_client, mock_store)
+
+ # Test _check_cache method directly using proper test data
+ messages = [system_prompt, UserMessage(content=prompts[1], source="user")]
+ cached_result, cache_key = cached_client._check_cache(messages, [], None, {}) # type: ignore
+
+ # Should return None (cache miss) when deserialization fails
+ assert cached_result is None
+ assert cache_key is not None
+
+
+def test_check_cache_redis_streaming_dict_deserialization() -> None:
+ """Test _check_cache with Redis streaming data containing dicts that need deserialization.
+ This tests the streaming scenario where Redis returns a list containing
+ serialized CreateResult objects as dictionaries mixed with string chunks.
+ """
+ _, prompts, system_prompt, replay_client, _ = get_test_data()
+
+ # Create a list with CreateResult objects mixed with strings (streaming scenario)
+ create_result = CreateResult(
+ content="final streaming response from redis",
+ usage=RequestUsage(prompt_tokens=12, completion_tokens=6),
+ cached=False,
+ finish_reason="stop",
+ )
+
+ cached_list: List[Union[str, CreateResult]] = [
+ "streaming chunk 1",
+ create_result, # Proper CreateResult object
+ "streaming chunk 2",
+ ]
+
+ # Mock cache store that returns the list with CreateResults (simulating Redis streaming)
+ mock_store = MockCacheStore(return_value=cached_list)
+ cached_client = ChatCompletionCache(replay_client, mock_store)
+
+ # Test _check_cache method directly using proper test data
+ messages = [system_prompt, UserMessage(content=prompts[2], source="user")]
+ cached_result, cache_key = cached_client._check_cache(messages, [], None, {}) # type: ignore
+
+ assert cached_result is not None
+ assert isinstance(cached_result, list)
+ assert len(cached_result) == 3
+ assert cached_result[0] == "streaming chunk 1"
+ assert isinstance(cached_result[1], CreateResult)
+ assert cached_result[1].content == "final streaming response from redis"
+ assert cached_result[2] == "streaming chunk 2"
+ assert cache_key is not None
+
+
+def test_check_cache_redis_streaming_deserialization_failure() -> None:
+ """Test _check_cache gracefully handles corrupted Redis streaming data.
+ This ensures the system degrades gracefully when Redis returns streaming
+ data with corrupted CreateResult dictionaries that cannot be deserialized.
+ """
+ _, prompts, system_prompt, replay_client, _ = get_test_data(num_messages=4)
+
+ # Mock cache store that returns None (simulating deserialization failure)
+ mock_store = MockCacheStore(return_value=None)
+ cached_client = ChatCompletionCache(replay_client, mock_store)
+
+ # Test _check_cache method directly using proper test data
+ messages = [system_prompt, UserMessage(content=prompts[0], source="user")]
+ cached_result, cache_key = cached_client._check_cache(messages, [], None, {}) # type: ignore
+
+ # Should return None (cache miss) when deserialization fails
+ assert cached_result is None
+ assert cache_key is not None
+
+
+def test_check_cache_dict_reconstruction_success() -> None:
+ """Test _check_cache successfully reconstructs CreateResult from a dict.
+ This tests the line: cached_result = CreateResult.model_validate(cached_result)
+ """
+ _, prompts, system_prompt, replay_client, _ = get_test_data()
+
+ # Create a dict that can be successfully validated as CreateResult
+ valid_dict = {
+ "content": "reconstructed response",
+ "usage": {"prompt_tokens": 10, "completion_tokens": 5},
+ "cached": False,
+ "finish_reason": "stop",
+ }
+
+ # Create a MockCacheStore that returns the dict directly (simulating Redis)
+ mock_store = MockCacheStore(return_value=cast(Any, valid_dict))
+ cached_client = ChatCompletionCache(replay_client, mock_store)
+
+ # Test _check_cache method
+ messages = [system_prompt, UserMessage(content=prompts[0], source="user")]
+ cached_result, cache_key = cached_client._check_cache(messages, [], None, {}) # type: ignore
+
+ # Should successfully reconstruct the CreateResult from dict
+ assert cached_result is not None
+ assert isinstance(cached_result, CreateResult)
+ assert cached_result.content == "reconstructed response"
+ assert cache_key is not None
+
+
+def test_check_cache_dict_reconstruction_failure() -> None:
+ """Test _check_cache handles ValidationError when dict cannot be reconstructed.
+ This tests the except ValidationError block for single dicts.
+ """
+ _, prompts, system_prompt, replay_client, _ = get_test_data()
+
+ # Create an invalid dict that will fail CreateResult validation
+ invalid_dict = {
+ "invalid_field": "value",
+ "missing_required_fields": True,
+ }
+
+ # Create a MockCacheStore that returns the invalid dict
+ mock_store = MockCacheStore(return_value=cast(Any, invalid_dict))
+ cached_client = ChatCompletionCache(replay_client, mock_store)
+
+ # Test _check_cache method
+ messages = [system_prompt, UserMessage(content=prompts[0], source="user")]
+ cached_result, cache_key = cached_client._check_cache(messages, [], None, {}) # type: ignore
+
+ # Should return None (cache miss) when reconstruction fails
+ assert cached_result is None
+ assert cache_key is not None
+
+
+def test_check_cache_list_reconstruction_success() -> None:
+ """Test _check_cache successfully reconstructs CreateResult objects from dicts in a list.
+ This tests the line: reconstructed_list.append(CreateResult.model_validate(item))
+ """
+ _, prompts, system_prompt, replay_client, _ = get_test_data()
+
+ # Create a list with valid dicts that can be reconstructed
+ valid_dict1 = {
+ "content": "first result",
+ "usage": {"prompt_tokens": 8, "completion_tokens": 3},
+ "cached": False,
+ "finish_reason": "stop",
+ }
+ valid_dict2 = {
+ "content": "second result",
+ "usage": {"prompt_tokens": 12, "completion_tokens": 7},
+ "cached": False,
+ "finish_reason": "stop",
+ }
+
+ cached_list = [
+ "streaming chunk 1",
+ valid_dict1,
+ "streaming chunk 2",
+ valid_dict2,
+ ]
+
+ # Create a MockCacheStore that returns the list with dicts
+ mock_store = MockCacheStore(return_value=cast(Any, cached_list))
+ cached_client = ChatCompletionCache(replay_client, mock_store)
+
+ # Test _check_cache method
+ messages = [system_prompt, UserMessage(content=prompts[0], source="user")]
+ cached_result, cache_key = cached_client._check_cache(messages, [], None, {}) # type: ignore
+
+ # Should successfully reconstruct the list with CreateResult objects
+ assert cached_result is not None
+ assert isinstance(cached_result, list)
+ assert len(cached_result) == 4
+ assert cached_result[0] == "streaming chunk 1"
+ assert isinstance(cached_result[1], CreateResult)
+ assert cached_result[1].content == "first result"
+ assert cached_result[2] == "streaming chunk 2"
+ assert isinstance(cached_result[3], CreateResult)
+ assert cached_result[3].content == "second result"
+ assert cache_key is not None
+
+
+def test_check_cache_list_reconstruction_failure() -> None:
+ """Test _check_cache handles ValidationError when list contains invalid dicts.
+ This tests the except ValidationError block for lists.
+ """
+ _, prompts, system_prompt, replay_client, _ = get_test_data()
+
+ # Create a list with an invalid dict that will fail validation
+ invalid_dict = {
+ "invalid_field": "value",
+ "missing_required": True,
+ }
+
+ cached_list = [
+ "streaming chunk 1",
+ invalid_dict, # This will cause ValidationError
+ "streaming chunk 2",
+ ]
+
+ # Create a MockCacheStore that returns the list with invalid dict
+ mock_store = MockCacheStore(return_value=cast(Any, cached_list))
+ cached_client = ChatCompletionCache(replay_client, mock_store)
+
+ # Test _check_cache method
+ messages = [system_prompt, UserMessage(content=prompts[0], source="user")]
+ cached_result, cache_key = cached_client._check_cache(messages, [], None, {}) # type: ignore
+
+ # Should return None (cache miss) when list reconstruction fails
+ assert cached_result is None
+ assert cache_key is not None
+
+
+def test_check_cache_already_correct_type() -> None:
+ """Test _check_cache returns data as-is when it's already the correct type.
+ This tests the final return path when no reconstruction is needed.
+ """
+ _, prompts, system_prompt, replay_client, _ = get_test_data()
+
+ # Create a proper CreateResult object (already correct type)
+ create_result = CreateResult(
+ content="already correct type",
+ usage=RequestUsage(prompt_tokens=15, completion_tokens=8),
+ cached=False,
+ finish_reason="stop",
+ )
+
+ # Create a MockCacheStore that returns the proper type
+ mock_store = MockCacheStore(return_value=create_result)
+ cached_client = ChatCompletionCache(replay_client, mock_store)
+
+ # Test _check_cache method
+ messages = [system_prompt, UserMessage(content=prompts[0], source="user")]
+ cached_result, cache_key = cached_client._check_cache(messages, [], None, {}) # type: ignore
+
+ # Should return the same object without reconstruction
+ assert cached_result is not None
+ assert cached_result is create_result # Same object reference
+ assert isinstance(cached_result, CreateResult)
+ assert cached_result.content == "already correct type"
+ assert cache_key is not None