Thought content is lost when model returns a handoff tool call

### What happened?

### Describe the bug
When using `AzureOpenAIChatCompletionClient`, the model sometimes returns both a meaningful message and a tool call simultaneously. If the tool call is a `handoff`, the content of the response becomes the `thought` in the result, but it is not included in the `HandoffMessage` context that is sent to the target agent. As a result, the receiving agent loses access to the original thought.

This behavior occurs because `_check_and_handle_handoff(...)` in `AssistantAgent` only includes the thought when there's at least one tool call in addition to the handoff tool call.

### To Reproduce

Use `AzureOpenAIChatCompletionClient` with a model that returns both a message content and a single handoff tool call.

Observe how the thought is not passed along in the `HandoffMessage` context.

Relevant snippet from `BaseOpenAIChatCompletionClient.create(...)`:

```
...
elif choice.message.tool_calls is not None and len(choice.message.tool_calls) > 0:
    ...
    if choice.message.content is not None and choice.message.content != "":
        # Put the content in the thought field.
        thought = choice.message.content
...
response = CreateResult(
    finish_reason=normalize_stop_reason(finish_reason),
    content=content,
    usage=usage,
    cached=False,
    logprobs=logprobs,
    thought=thought,
)
```
And from `AssistantAgent._check_and_handle_handoff(...)`:

```
...
if len(tool_calls) > 0: 
    # Only includes the thought if there are other tool calls besides the handoff
    handoff_context.append(
        AssistantMessage(
            content=tool_calls,
            source=agent_name,
            thought=getattr(model_result, "thought", None),
        )
    )
```
If there's only a single handoff tool call, and no other calls, the thought is not included.

### Expected behavior
Even if the only tool call present is a handoff, the model's thought (i.e., the message content) should still be passed in the `HandoffMessage` context, so the receiving agent has full context.

### Quick Fix / Workaround
As a workaround, I subclassed `AssistantAgent` and patched `_check_and_handle_handoff(...)` to also include the thought as a `UserMessage` if no other tool calls are present:

```
...
if len(tool_calls) > 0:
    handoff_context.append(
        AssistantMessage(
            content=tool_calls,
            source=agent_name,
            thought=getattr(model_result, "thought", None),
        )
    )
    handoff_context.append(FunctionExecutionResultMessage(content=tool_call_results))

# MANUAL QUICK FIX
elif has_thought:
    handoff_context.append(
        UserMessage(
            content=model_result.thought,
            source=agent_name,
        )
    )

return Response(
    chat_message=HandoffMessage(
        content=selected_handoff_message,
        target=selected_handoff.target,
        source=agent_name,
        context=handoff_context,
    ),
    inner_messages=inner_messages,
)
```
### Additional context

- I initially attempted to prompt the model to emit a regular message before making a tool call, but this approach did only work out okayish
- The manual fix works more robust and should not introduce any side-effects, thought it most likely is not the proper solution

### Which packages was the bug in?

Python AgentChat (autogen-agentchat>=0.4.0)

### AutoGen library version.

Python 0.5.1

### Other library version.

_No response_

### Model used

gpt4o

### Model provider

Azure OpenAI

### Other model provider

_No response_

### Python version

3.11

### .NET version

None

### Operating system

None

Labels: help wanted, proj-agentchat
State: closed