Tool use fails when streaming

### What happened?

**Describe the bug**
When performing tool use with streaming with bedrock with Claude - it fails. When I turn off streaming, it works fine.

**To Reproduce**
```
import asyncio
import json

import boto3
from autogen_agentchat.agents import AssistantAgent
from autogen_core.models import ModelInfo
from autogen_ext.models.anthropic import BedrockInfo, AnthropicBedrockChatCompletionClient


# Define a function that returns a dictionary (similar to your get_current_crop)
async def get_dictionary_data() -> dict:
    """Get some dictionary data"""
    return {
        "key1": 123,
        "key2": "value",
        "key3": True
    }

# Define a function that returns a JSON string
async def get_json_string_data() -> str:
    """Get some JSON string data"""
    return json.dumps({
        "key1": 123,
        "key2": "value",
        "key3": True
    })

async def run_test(streaming=True):
    print(f"\n--- Testing with model_client_stream={streaming} ---")

    credentials = ...
    region_name = ...
    bedrock_model_id = 'anthropic.claude-3-5-sonnet-20240620-v1:0'
    # Create model client
    bedrock_info = BedrockInfo(
        aws_access_key=credentials["AccessKeyId"],
        aws_secret_key=credentials["SecretAccessKey"],
        aws_session_token=credentials["SessionToken"],
        aws_region=region_name,
    )

    # Create the client
    model_client = AnthropicBedrockChatCompletionClient(
        model=bedrock_model_id,
        temperature=0.1,
        max_tokens=4096,
        model_info=ModelInfo(
                vision=False,
                function_calling=True,
                json_output=False,
                family='claude-3-5-sonnet',
                structured_output=True,
            ),
        bedrock_info=bedrock_info,
    )

    # Create agent with the specified streaming setting
    agent = AssistantAgent(
        name="assistant",
        model_client=model_client,
        model_client_stream=streaming,
        tools=[get_dictionary_data, get_json_string_data]
    )

    try:
        # Run the agent with a task that will trigger both functions
        result = await agent.run(
            task="First call get_dictionary_data and then call get_json_string_data. Compare the results."
        )
        print("Success! Agent completed the task.")
        print(f"Last message: {result.messages[-1].content}")
    except Exception as e:
        print(f"Error occurred: {type(e).__name__}: {str(e)}")

async def main():
    # Test with streaming enabled
    await run_test(streaming=True)

    # Test with streaming disabled
    await run_test(streaming=False)


if __name__ == "__main__":
    asyncio.run(main())

```

Output:
```
--- Testing with model_client_stream=True ---
Success! Agent completed the task.
Last message: Error: Expecting value: line 1 column 1 (char 0)
Error: Expecting value: line 1 column 1 (char 0)

--- Testing with model_client_stream=False ---
Success! Agent completed the task.
Last message: {'key1': 123, 'key2': 'value', 'key3': True}
{"key1": 123, "key2": "value", "key3": true}
```

**Expected behavior**
Both modes should work the same

**Additional context**
I noticed that in non-stream mode, the arguments for the functions are '{}' while for streaming mode the arguments are ''.


### Which packages was the bug in?

Python Core (autogen-core)

### AutoGen library version.

Python dev (main branch)

### Other library version.

_No response_

### Model used

claude-3-5-sonnet

### Model provider

AWS Bedrock

### Other model provider

_No response_

### Python version

3.11

### .NET version

None

### Operating system

Ubuntu

Labels: needs-triage
State: closed