fast-agent-mcp 0.2.35__py3-none-any.whl → 0.2.37__py3-none-any.whl

mcp_agent/human_input/elicitation_forms.py

@@ -0,0 +1,59 @@
+"""Shared styling configuration for MCP elicitation forms."""
+
+from prompt_toolkit.styles import Style
+
+# Define consistent elicitation style - inspired by usage display and interactive prompt
+ELICITATION_STYLE = Style.from_dict(
+    {
+        # Dialog structure - use ansidefault for true black, remove problematic shadow
+        "dialog": "bg:ansidefault",  # True black dialog using ansidefault
+        "dialog.body": "bg:ansidefault fg:ansiwhite",  # True black dialog body
+        "dialog shadow": "bg:ansidefault",  # Set shadow background to match application
+        "dialog.border": "bg:ansidefault",  # True black border background
+        # Set application background to true black
+        "application": "bg:ansidefault",  # True black application background
+        # Title styling with better contrast
+        "title": "fg:ansibrightmagenta bold",  # Bright magenta text
+        # Buttons - only define focused state to preserve focus highlighting
+        "button.focused": "bg:ansibrightgreen fg:ansiblack bold",  # Bright green with black text for contrast
+        "button.arrow": "fg:ansiwhite bold",  # White arrows for visibility
+        # Form elements with consistent green/yellow theme
+        # Checkboxes - green when checked, yellow when focused
+        "checkbox": "fg:ansidefault",  # Default color unchecked checkbox (dimmer)
+        "checkbox-checked": "fg:ansibrightgreen bold",  # Green when checked (matches buttons)
+        "checkbox-selected": "bg:ansidefault fg:ansibrightyellow bold",  # Yellow when focused
+        # Radio list styling - consistent with checkbox colors
+        "radio-list": "bg:ansidefault",  # True black background for radio list
+        "radio": "fg:ansidefault",  # Default color for unselected items (dimmer)
+        "radio-selected": "bg:ansidefault fg:ansibrightyellow bold",  # Yellow when focused
+        "radio-checked": "fg:ansibrightgreen bold",  # Green when selected (matches buttons)
+        # Text input areas - use ansidefault for non-focused (dimmer effect)
+        "input-field": "fg:ansidefault bold",  # Default color (inactive) - should be dimmer than white
+        "input-field.focused": "fg:ansibrightyellow bold",  # Bright yellow (active)
+        "input-field.error": "fg:ansired bold",  # Red text (validation error)
+        # Frame styling with ANSI colors - make borders visible
+        "frame.border": "fg:ansibrightblack",  # Bright black borders for subtlety
+        "frame.label": "fg:ansigray",  # Gray frame labels (less prominent)
+        # Labels and text - use white for good visibility
+        "label": "fg:ansiwhite",  # White labels for good readability
+        "message": "fg:ansibrightcyan",  # Bright cyan messages (no bold)
+        # Agent and server names - make them match
+        "agent-name": "fg:ansibrightblue bold",
+        "server-name": "fg:ansibrightblue bold",  # Same color as agent
+        # Validation errors - better contrast
+        "validation-toolbar": "bg:ansibrightred fg:ansiwhite bold",
+        "validation-toolbar.text": "bg:ansibrightred fg:ansiwhite",
+        "validation.border": "fg:ansibrightred",
+        "validation-error": "fg:ansibrightred bold",  # For status line errors
+        # Separator styling
+        "separator": "fg:ansibrightblue bold",
+        # Completion menu - exactly matching enhanced_prompt.py
+        "completion-menu.completion": "bg:ansiblack fg:ansigreen",
+        "completion-menu.completion.current": "bg:ansiblack fg:ansigreen bold",
+        "completion-menu.meta.completion": "bg:ansiblack fg:ansiblue",
+        "completion-menu.meta.completion.current": "bg:ansibrightblack fg:ansiblue",
+        # Toolbar - matching enhanced_prompt.py exactly
+        "bottom-toolbar": "fg:ansiblack bg:ansigray",
+        "bottom-toolbar.text": "fg:ansiblack bg:ansigray",
+    }
+)

mcp_agent/human_input/elicitation_handler.py

@@ -0,0 +1,88 @@
+from typing import Any, Dict, Optional
+
+from mcp_agent.human_input.elicitation_form import (
+    show_simple_elicitation_form,
+)
+from mcp_agent.human_input.elicitation_forms import (
+    ELICITATION_STYLE,
+)
+from mcp_agent.human_input.elicitation_state import elicitation_state
+from mcp_agent.human_input.types import (
+    HumanInputRequest,
+    HumanInputResponse,
+)
+from mcp_agent.progress_display import progress_display
+
+
+async def elicitation_input_callback(
+    request: HumanInputRequest,
+    agent_name: str | None = None,
+    server_name: str | None = None,
+    server_info: dict[str, Any] | None = None,
+) -> HumanInputResponse:
+    """Request input from a human user for MCP server elicitation requests."""
+
+    # Extract effective names
+    effective_agent_name = agent_name or (
+        request.metadata.get("agent_name", "Unknown Agent") if request.metadata else "Unknown Agent"
+    )
+    effective_server_name = server_name or "Unknown Server"
+
+    # Check if elicitation is disabled for this server
+    if elicitation_state.is_disabled(effective_server_name):
+        return HumanInputResponse(
+            request_id=request.request_id,
+            response="__CANCELLED__",
+            metadata={"auto_cancelled": True, "reason": "Server elicitation disabled by user"},
+        )
+
+    # Get the elicitation schema from metadata
+    schema: Optional[Dict[str, Any]] = None
+    if request.metadata and "requested_schema" in request.metadata:
+        schema = request.metadata["requested_schema"]
+
+    # Use the context manager to pause the progress display while getting input
+    with progress_display.paused():
+        try:
+            if schema:
+                form_action, form_data = await show_simple_elicitation_form(
+                    schema=schema,
+                    message=request.prompt,
+                    agent_name=effective_agent_name,
+                    server_name=effective_server_name,
+                )
+
+                if form_action == "accept" and form_data is not None:
+                    # Convert form data to JSON string
+                    import json
+
+                    response = json.dumps(form_data)
+                elif form_action == "decline":
+                    response = "__DECLINED__"
+                elif form_action == "disable":
+                    response = "__DISABLE_SERVER__"
+                else:  # cancel
+                    response = "__CANCELLED__"
+            else:
+                # No schema, fall back to text input using prompt_toolkit only
+                from prompt_toolkit.shortcuts import input_dialog
+
+                response = await input_dialog(
+                    title="Input Requested",
+                    text=f"Agent: {effective_agent_name}\nServer: {effective_server_name}\n\n{request.prompt}",
+                    style=ELICITATION_STYLE,
+                ).run_async()
+
+                if response is None:
+                    response = "__CANCELLED__"
+
+        except KeyboardInterrupt:
+            response = "__CANCELLED__"
+        except EOFError:
+            response = "__CANCELLED__"
+
+    return HumanInputResponse(
+        request_id=request.request_id,
+        response=response.strip() if isinstance(response, str) else response,
+        metadata={"has_schema": schema is not None},
+    )

mcp_agent/human_input/elicitation_state.py

@@ -0,0 +1,34 @@
+"""Simple state management for elicitation Cancel All functionality."""
+
+from typing import Set
+
+
+class ElicitationState:
+    """Manages global state for elicitation requests, including disabled servers."""
+    
+    def __init__(self):
+        self.disabled_servers: Set[str] = set()
+    
+    def disable_server(self, server_name: str) -> None:
+        """Disable elicitation requests for a specific server."""
+        self.disabled_servers.add(server_name)
+    
+    def is_disabled(self, server_name: str) -> bool:
+        """Check if elicitation is disabled for a server."""
+        return server_name in self.disabled_servers
+    
+    def enable_server(self, server_name: str) -> None:
+        """Re-enable elicitation requests for a specific server."""
+        self.disabled_servers.discard(server_name)
+    
+    def clear_all(self) -> None:
+        """Clear all disabled servers."""
+        self.disabled_servers.clear()
+    
+    def get_disabled_servers(self) -> Set[str]:
+        """Get a copy of all disabled servers."""
+        return self.disabled_servers.copy()
+
+
+# Global instance for session-scoped Cancel All functionality
+elicitation_state = ElicitationState()

mcp_agent/llm/augmented_llm.py

@@ -554,6 +554,37 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         }
         self.logger.debug("Chat in progress", data=data)
 
+    def _update_streaming_progress(self, content: str, model: str, estimated_tokens: int) -> int:
+        """Update streaming progress with token estimation and formatting.
+        
+        Args:
+            content: The text content from the streaming event
+            model: The model name
+            estimated_tokens: Current token count to update
+            
+        Returns:
+            Updated estimated token count
+        """
+        # Rough estimate: 1 token per 4 characters (OpenAI's typical ratio)
+        text_length = len(content)
+        additional_tokens = max(1, text_length // 4)
+        new_total = estimated_tokens + additional_tokens
+        
+        # Format token count for display
+        token_str = str(new_total).rjust(5)
+        
+        # Emit progress event
+        data = {
+            "progress_action": ProgressAction.STREAMING,
+            "model": model,
+            "agent_name": self.name,
+            "chat_turn": self.chat_turn(),
+            "details": token_str.strip(),  # Token count goes in details for STREAMING action
+        }
+        self.logger.info("Streaming progress", data=data)
+        
+        return new_total
+
     def _log_chat_finished(self, model: Optional[str] = None) -> None:
         """Log a chat finished event"""
         data = {

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -111,14 +111,8 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 and hasattr(event, "delta")
                 and event.delta.type == "text_delta"
             ):
-                # Rough estimate: 1 token per 4 characters (OpenAI's typical ratio)
-                text_length = len(event.delta.text)
-                estimated_tokens += max(1, text_length // 4)
-
-                # Update progress on every token for real-time display
-                token_str = str(estimated_tokens).rjust(5)
-                #                print(f"DEBUG: Streaming tokens: {token_str}")
-                self._emit_streaming_progress(model, token_str)
+                # Use base class method for token estimation and progress emission
+                estimated_tokens = self._update_streaming_progress(event.delta.text, model, estimated_tokens)
 
             # Also check for final message_delta events with actual usage info
             elif (
@@ -127,9 +121,16 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 and event.usage.output_tokens
             ):
                 actual_tokens = event.usage.output_tokens
+                # Emit final progress with actual token count
                 token_str = str(actual_tokens).rjust(5)
-                #               print(f"DEBUG: Final actual tokens: {token_str}")
-                self._emit_streaming_progress(model, token_str)
+                data = {
+                    "progress_action": ProgressAction.STREAMING,
+                    "model": model,
+                    "agent_name": self.name,
+                    "chat_turn": self.chat_turn(),
+                    "details": token_str.strip(),
+                }
+                self.logger.info("Streaming progress", data=data)
 
         # Get the final message with complete usage data
         message = await stream.get_final_message()
@@ -142,19 +143,6 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         return message
 
-    def _emit_streaming_progress(self, model: str, token_str: str) -> None:
-        """Emit a streaming progress event that goes directly to progress display."""
-        data = {
-            "progress_action": ProgressAction.STREAMING,
-            "model": model,
-            "agent_name": self.name,
-            "chat_turn": self.chat_turn(),
-            "details": token_str.strip(),  # Token count goes in details for STREAMING action
-        }
-        #        print(f"DEBUG: Emitting streaming progress event with data: {data}")
-        # Use a special logger level or namespace to avoid polluting regular logs
-        self.logger.info("Streaming progress", data=data)
-
     async def _anthropic_completion(
         self,
         message_param,

mcp_agent/llm/providers/augmented_llm_azure.py

@@ -1,4 +1,4 @@
-from openai import AuthenticationError, AzureOpenAI, OpenAI
+from openai import AsyncAzureOpenAI, AsyncOpenAI, AuthenticationError
 
 from mcp_agent.core.exceptions import ProviderKeyError
 from mcp_agent.llm.provider_types import Provider
@@ -93,7 +93,7 @@ class AzureOpenAIAugmentedLLM(OpenAIAugmentedLLM):
             if not self.resource_name and self.base_url:
                 self.resource_name = _extract_resource_name(self.base_url)
 
-    def _openai_client(self) -> OpenAI:
+    def _openai_client(self) -> AsyncOpenAI:
         """
         Returns an AzureOpenAI client, handling both API Key and DefaultAzureCredential.
         """
@@ -104,7 +104,7 @@ class AzureOpenAIAugmentedLLM(OpenAIAugmentedLLM):
                         "Missing Azure endpoint",
                         "azure_endpoint (base_url) is None at client creation time.",
                     )
-                return AzureOpenAI(
+                return AsyncAzureOpenAI(
                     azure_ad_token_provider=self.get_azure_token,
                     azure_endpoint=self.base_url,
                     api_version=self.api_version,
@@ -116,7 +116,7 @@ class AzureOpenAIAugmentedLLM(OpenAIAugmentedLLM):
                         "Missing Azure endpoint",
                         "azure_endpoint (base_url) is None at client creation time.",
                     )
-                return AzureOpenAI(
+                return AsyncAzureOpenAI(
                     api_key=self.api_key,
                     azure_endpoint=self.base_url,
                     api_version=self.api_version,

mcp_agent/llm/providers/augmented_llm_google_native.py

@@ -242,8 +242,10 @@ class GoogleNativeAugmentedLLM(AugmentedLLM[types.Content, types.Content]):
                 self.history.get(include_completion_history=True)
             )
         else:
-            # If not using history, start with an empty list
-            conversation_history = []
+            # If not using history, convert the last message to google.genai format
+            conversation_history = self._converter.convert_to_google_content(
+                self.history.get(include_completion_history=True)[-1:]
+            )
 
         self.logger.debug(f"Google completion requested with messages: {conversation_history}")
         self._log_chat_progress(

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -8,7 +8,8 @@ from mcp.types import (
     ImageContent,
     TextContent,
 )
-from openai import AuthenticationError, OpenAI
+from openai import AsyncOpenAI, AuthenticationError
+from openai.lib.streaming.chat import ChatCompletionStreamState
 
 # from openai.types.beta.chat import
 from openai.types.chat import (
@@ -22,6 +23,7 @@ from rich.text import Text
 
 from mcp_agent.core.exceptions import ProviderKeyError
 from mcp_agent.core.prompt import Prompt
+from mcp_agent.event_progress import ProgressAction
 from mcp_agent.llm.augmented_llm import (
     AugmentedLLM,
     RequestParams,
@@ -103,9 +105,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
     def _base_url(self) -> str:
         return self.context.config.openai.base_url if self.context.config.openai else None
 
-    def _openai_client(self) -> OpenAI:
+    def _openai_client(self) -> AsyncOpenAI:
         try:
-            return OpenAI(api_key=self._api_key(), base_url=self._base_url())
+            return AsyncOpenAI(api_key=self._api_key(), base_url=self._base_url())
         except AuthenticationError as e:
             raise ProviderKeyError(
                 "Invalid OpenAI API key",
@@ -113,6 +115,182 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                 "Please check that your API key is valid and not expired.",
             ) from e
 
+    async def _process_stream(self, stream, model: str):
+        """Process the streaming response and display real-time token usage."""
+        # Track estimated output tokens by counting text chunks
+        estimated_tokens = 0
+
+        # For non-OpenAI providers (like Ollama), ChatCompletionStreamState might not work correctly
+        # Fall back to manual accumulation if needed
+        # TODO -- consider this and whether to subclass instead
+        if self.provider in [Provider.GENERIC, Provider.OPENROUTER, Provider.GOOGLE_OAI]:
+            return await self._process_stream_manual(stream, model)
+
+        # Use ChatCompletionStreamState helper for accumulation (OpenAI only)
+        state = ChatCompletionStreamState()
+
+        # Process the stream chunks
+        async for chunk in stream:
+            # Handle chunk accumulation
+            state.handle_chunk(chunk)
+
+            # Count tokens in real-time from content deltas
+            if chunk.choices and chunk.choices[0].delta.content:
+                content = chunk.choices[0].delta.content
+                # Use base class method for token estimation and progress emission
+                estimated_tokens = self._update_streaming_progress(content, model, estimated_tokens)
+
+        # Get the final completion with usage data
+        final_completion = state.get_final_completion()
+
+        # Log final usage information
+        if hasattr(final_completion, "usage") and final_completion.usage:
+            actual_tokens = final_completion.usage.completion_tokens
+            # Emit final progress with actual token count
+            token_str = str(actual_tokens).rjust(5)
+            data = {
+                "progress_action": ProgressAction.STREAMING,
+                "model": model,
+                "agent_name": self.name,
+                "chat_turn": self.chat_turn(),
+                "details": token_str.strip(),
+            }
+            self.logger.info("Streaming progress", data=data)
+
+            self.logger.info(
+                f"Streaming complete - Model: {model}, Input tokens: {final_completion.usage.prompt_tokens}, Output tokens: {final_completion.usage.completion_tokens}"
+            )
+
+        return final_completion
+
+    # TODO - as per other comment this needs to go in another class. There are a number of "special" cases dealt with
+    # here to deal with OpenRouter idiosyncrasies between e.g. Anthropic and Gemini models.
+    async def _process_stream_manual(self, stream, model: str):
+        """Manual stream processing for providers like Ollama that may not work with ChatCompletionStreamState."""
+        from openai.types.chat import ChatCompletionMessageToolCall
+        from openai.types.chat.chat_completion_message_tool_call import Function
+
+        # Track estimated output tokens by counting text chunks
+        estimated_tokens = 0
+
+        # Manual accumulation of response data
+        accumulated_content = ""
+        role = "assistant"
+        tool_calls_map = {}  # Use a map to accumulate tool calls by index
+        function_call = None
+        finish_reason = None
+        usage_data = None
+
+        # Process the stream chunks manually
+        async for chunk in stream:
+            # Count tokens in real-time from content deltas
+            if chunk.choices and chunk.choices[0].delta.content:
+                content = chunk.choices[0].delta.content
+                accumulated_content += content
+                # Use base class method for token estimation and progress emission
+                estimated_tokens = self._update_streaming_progress(content, model, estimated_tokens)
+
+            # Extract other fields from the chunk
+            if chunk.choices:
+                choice = chunk.choices[0]
+                if choice.delta.role:
+                    role = choice.delta.role
+                if choice.delta.tool_calls:
+                    # Accumulate tool call deltas
+                    for delta_tool_call in choice.delta.tool_calls:
+                        if delta_tool_call.index is not None:
+                            if delta_tool_call.index not in tool_calls_map:
+                                tool_calls_map[delta_tool_call.index] = {
+                                    "id": delta_tool_call.id,
+                                    "type": delta_tool_call.type or "function",
+                                    "function": {
+                                        "name": delta_tool_call.function.name
+                                        if delta_tool_call.function
+                                        else None,
+                                        "arguments": "",
+                                    },
+                                }
+
+                            # Always update if we have new data (needed for OpenRouter Gemini)
+                            if delta_tool_call.id:
+                                tool_calls_map[delta_tool_call.index]["id"] = delta_tool_call.id
+                            if delta_tool_call.function:
+                                if delta_tool_call.function.name:
+                                    tool_calls_map[delta_tool_call.index]["function"]["name"] = (
+                                        delta_tool_call.function.name
+                                    )
+                                # Handle arguments - they might come as None, empty string, or actual content
+                                if delta_tool_call.function.arguments is not None:
+                                    tool_calls_map[delta_tool_call.index]["function"][
+                                        "arguments"
+                                    ] += delta_tool_call.function.arguments
+
+                if choice.delta.function_call:
+                    function_call = choice.delta.function_call
+                if choice.finish_reason:
+                    finish_reason = choice.finish_reason
+
+            # Extract usage data if available
+            if hasattr(chunk, "usage") and chunk.usage:
+                usage_data = chunk.usage
+
+        # Convert accumulated tool calls to proper format.
+        tool_calls = None
+        if tool_calls_map:
+            tool_calls = []
+            for idx in sorted(tool_calls_map.keys()):
+                tool_call_data = tool_calls_map[idx]
+                # Only add tool calls that have valid data
+                if tool_call_data["id"] and tool_call_data["function"]["name"]:
+                    tool_calls.append(
+                        ChatCompletionMessageToolCall(
+                            id=tool_call_data["id"],
+                            type=tool_call_data["type"],
+                            function=Function(
+                                name=tool_call_data["function"]["name"],
+                                arguments=tool_call_data["function"]["arguments"],
+                            ),
+                        )
+                    )
+
+        # Create a ChatCompletionMessage manually
+        message = ChatCompletionMessage(
+            content=accumulated_content,
+            role=role,
+            tool_calls=tool_calls if tool_calls else None,
+            function_call=function_call,
+            refusal=None,
+            annotations=None,
+            audio=None,
+        )
+
+        from types import SimpleNamespace
+
+        final_completion = SimpleNamespace()
+        final_completion.choices = [SimpleNamespace()]
+        final_completion.choices[0].message = message
+        final_completion.choices[0].finish_reason = finish_reason
+        final_completion.usage = usage_data
+
+        # Log final usage information
+        if usage_data:
+            actual_tokens = getattr(usage_data, "completion_tokens", estimated_tokens)
+            token_str = str(actual_tokens).rjust(5)
+            data = {
+                "progress_action": ProgressAction.STREAMING,
+                "model": model,
+                "agent_name": self.name,
+                "chat_turn": self.chat_turn(),
+                "details": token_str.strip(),
+            }
+            self.logger.info("Streaming progress", data=data)
+
+            self.logger.info(
+                f"Streaming complete - Model: {model}, Input tokens: {getattr(usage_data, 'prompt_tokens', 0)}, Output tokens: {actual_tokens}"
+            )
+
+        return final_completion
+
     async def _openai_completion(
         self,
         message: OpenAIMessage,
@@ -151,7 +329,10 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         ]
 
         if not available_tools:
-            available_tools = None  # deepseek does not allow empty array
+            if self.provider == Provider.DEEPSEEK:
+                available_tools = None  # deepseek does not allow empty array
+            else:
+                available_tools = []
 
         # we do NOT send "stop sequences" as this causes errors with mutlimodal processing
         for i in range(request_params.max_iterations):
@@ -160,11 +341,10 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
             self._log_chat_progress(self.chat_turn(), model=self.default_request_params.model)
 
-            executor_result = await self.executor.execute(
-                self._openai_client().chat.completions.create, **arguments
-            )
-
-            response = executor_result[0]
+            # Use basic streaming API
+            stream = await self._openai_client().chat.completions.create(**arguments)
+            # Process the stream
+            response = await self._process_stream(stream, self.default_request_params.model)
 
             # Track usage if response is valid and has usage data
             if (
@@ -204,10 +384,11 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             if message.content:
                 responses.append(TextContent(type="text", text=message.content))
 
-            converted_message = self.convert_message_to_message_param(message)
-            messages.append(converted_message)
+            # ParsedChatCompletionMessage is compatible with ChatCompletionMessage
+            # since it inherits from it, so we can use it directly
+            messages.append(message)
 
-            message_text = converted_message.content
+            message_text = message.content
             if choice.finish_reason in ["tool_calls", "function_call"] and message.tool_calls:
                 if message_text:
                     await self.show_assistant_message(
@@ -347,6 +528,8 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             "model": self.default_request_params.model,
             "messages": messages,
             "tools": tools,
+            "stream": True,  # Enable basic streaming
+            "stream_options": {"include_usage": True},  # Required for usage data in streaming
         }
 
         if self._reasoning:

mcp_agent/llm/providers/multipart_converter_openai.py

@@ -360,7 +360,7 @@ class OpenAIConverter:
             return {
                 "role": "tool",
                 "tool_call_id": tool_call_id,
-                "content": "[No content in tool result]",
+                "content": "[Tool completed successfully]",
             }
 
         # Separate text and non-text content
@@ -387,8 +387,9 @@ class OpenAIConverter:
                 converted.get("content", "")
             )
 
-        if not tool_message_content:
-            tool_message_content = "[Tool returned non-text content]"
+        # Ensure we always have non-empty content for compatibility
+        if not tool_message_content or tool_message_content.strip() == "":
+            tool_message_content = "[Tool completed successfully]"
 
         # Create the tool message with just the text
         tool_message = {