Redis caching always return False due to unmet condition

### What happened?

**Describe the bug**
Retriving from cache is skipped due to unhandled condition for the string type as shown below, making caching False everytime even if the key is already present in redis, making it call the LLM everytime even when it is present

**To Reproduce**
Run the following code (from the documentation itself) and make sure to add needed variables in your env:
```
import asyncio

from autogen_core.models import UserMessage, CreateResult
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.models.cache import ChatCompletionCache, CHAT_CACHE_VALUE_TYPE
from autogen_ext.cache_store.redis import RedisStore
import redis
import os
from dotenv import load_dotenv

load_dotenv()

async def main():
    # Initialize the original client
    
    openai_model_client = OpenAIChatCompletionClient(
            model=os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
            api_key=os.getenv("OPENAI_API_KEY"),
            )
    # Initialize Redis cache store
    redis_instance = redis.Redis(
        host=os.getenv("AZURE_REDIS_HOST"),
        port=int(os.getenv("AZURE_REDIS_PORT")),
        password=os.getenv("AZURE_REDIS_PASSWORD"),
        username=os.getenv("AZURE_REDIS_USERNAME"),
        ssl=True,
        ssl_cert_reqs=None,
        decode_responses=True
    )

    print("Keys Before:", redis_instance.keys())
    cache_store = RedisStore[CHAT_CACHE_VALUE_TYPE](redis_instance)
    cache_client = ChatCompletionCache(openai_model_client, cache_store)

    response = await cache_client.create([UserMessage(content="what is the capital of france", source="user")])
    print("\n\nFirst response:", response)  # Should print response from OpenAI
    print("\nKeys After first call:", redis_instance.keys())
    response = await cache_client.create([UserMessage(content="what is the capital of france", source="user")])
    print("\n\nSecond response:", response)  # Should print cached response
    print("\nKeys After second call:", redis_instance.keys())


asyncio.run(main())
```

**Expected behavior**
from the documentation it was supposed to return the first call from openai but the 2nd call from the cache, it didnt and it made another call to openai and returned cache=False

**Screenshots**

<img width="1268" height="947" alt="Image" src="https://github.com/user-attachments/assets/e4d31b51-5a8d-480e-af63-b450c8554279" />

**Additional context**
After debugging in line 248, it finds the key and the cached result, but it is returned as type "str" so when it enters  the condition in line 250 and 254 both fails making it skip it and goes to call the LLM again in line 262 and also a comment is left in line 260 explaining that this was going to happen

<img width="847" height="578" alt="Image" src="https://github.com/user-attachments/assets/a158f33f-8856-4ad2-a0cf-20cc2bb7fac1" />


### Which packages was the bug in?

Python Extensions (autogen-ext)

### AutoGen library version.

Python dev (main branch)

### Other library version.

0.7.4

### Model used

gpt-4o-mini

### Model provider

OpenAI

### Other model provider

_No response_

### Python version

3.12

### .NET version

None

### Operating system

MacOS

Labels: needs-triage
State: closed