fast-agent-mcp 0.2.57__py3-none-any.whl → 0.3.0__py3-none-any.whl

mcp_agent/llm/providers/augmented_llm_tensorzero_openai.py → fast_agent/llm/provider/openai/llm_tensorzero_openai.py

@@ -2,12 +2,12 @@ from typing import Any, Dict, List, Optional
 
 from openai.types.chat import ChatCompletionMessageParam, ChatCompletionSystemMessageParam
 
-from mcp_agent.core.request_params import RequestParams
-from mcp_agent.llm.provider_types import Provider
-from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+from fast_agent.llm.provider.openai.llm_openai import OpenAILLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.types import RequestParams
 
 
-class TensorZeroOpenAIAugmentedLLM(OpenAIAugmentedLLM):
+class TensorZeroOpenAILLM(OpenAILLM):
     """
     An LLM augmentation that interacts with TensorZero's OpenAI-compatible inference endpoint.
     This class extends the base OpenAIAugmentedLLM to handle TensorZero-specific
@@ -55,7 +55,7 @@ class TensorZeroOpenAIAugmentedLLM(OpenAIAugmentedLLM):
         if self.context and self.context.config and hasattr(self.context.config, "tensorzero"):
             base_url = getattr(self.context.config.tensorzero, "base_url", default_url)
             # Ensure the path is correctly appended
-            if not base_url.endswith('/openai/v1'):
+            if not base_url.endswith("/openai/v1"):
                 base_url = f"{base_url.rstrip('/')}/openai/v1"
             self.logger.debug(f"Using TensorZero base URL from config: {base_url}")
             return base_url
@@ -63,10 +63,10 @@ class TensorZeroOpenAIAugmentedLLM(OpenAIAugmentedLLM):
         return default_url
 
     def _prepare_api_request(
-            self,
-            messages: List[ChatCompletionMessageParam],
-            tools: Optional[List[Any]],
-            request_params: RequestParams
+        self,
+        messages: List[ChatCompletionMessageParam],
+        tools: Optional[List[Any]],
+        request_params: RequestParams,
     ) -> Dict[str, Any]:
         """
         Prepares the API request for the TensorZero OpenAI-compatible endpoint.
@@ -87,8 +87,7 @@ class TensorZeroOpenAIAugmentedLLM(OpenAIAugmentedLLM):
                     # If content is a string, convert it to the TensorZero format
                     if isinstance(msg.get("content"), str):
                         messages[i] = ChatCompletionSystemMessageParam(
-                            role="system",
-                            content=[request_params.template_vars]
+                            role="system", content=[request_params.template_vars]
                         )
                     elif isinstance(msg.get("content"), list):
                         # If content is already a list, merge the template vars
@@ -98,10 +97,12 @@ class TensorZeroOpenAIAugmentedLLM(OpenAIAugmentedLLM):
 
             if not system_message_found:
                 # If no system message exists, create one
-                messages.insert(0, ChatCompletionSystemMessageParam(
-                    role="system",
-                    content=[request_params.template_vars]
-                ))
+                messages.insert(
+                    0,
+                    ChatCompletionSystemMessageParam(
+                        role="system", content=[request_params.template_vars]
+                    ),
+                )
 
         # Add TensorZero-specific extra body parameters
         extra_body = arguments.get("extra_body", {})
@@ -124,4 +125,4 @@ class TensorZeroOpenAIAugmentedLLM(OpenAIAugmentedLLM):
             arguments["extra_body"] = extra_body
 
         self.logger.debug(f"Final API request arguments: {arguments}")
-        return arguments
+        return arguments

mcp_agent/llm/providers/augmented_llm_xai.py → fast_agent/llm/provider/openai/llm_xai.py

@@ -1,14 +1,14 @@
 import os
 
-from mcp_agent.core.request_params import RequestParams
-from mcp_agent.llm.provider_types import Provider
-from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+from fast_agent.llm.provider.openai.llm_openai import OpenAILLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.types import RequestParams
 
 XAI_BASE_URL = "https://api.x.ai/v1"
 DEFAULT_XAI_MODEL = "grok-3"
 
 
-class XAIAugmentedLLM(OpenAIAugmentedLLM):
+class XAILLM(OpenAILLM):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(
             *args, provider=Provider.XAI, **kwargs
@@ -18,12 +18,12 @@ class XAIAugmentedLLM(OpenAIAugmentedLLM):
         """Initialize xAI parameters"""
         # Get base defaults from parent (includes ModelDatabase lookup)
         base_params = super()._initialize_default_params(kwargs)
-        
+
         # Override with xAI-specific settings
         chosen_model = kwargs.get("model", DEFAULT_XAI_MODEL)
         base_params.model = chosen_model
         base_params.parallel_tool_calls = False
-        
+
         return base_params
 
     def _base_url(self) -> str:

{mcp_agent/llm/providers → fast_agent/llm/provider/openai}/multipart_converter_openai.py

@@ -1,3 +1,4 @@
+import json
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from mcp.types import (
@@ -5,13 +6,12 @@ from mcp.types import (
     EmbeddedResource,
     ImageContent,
     PromptMessage,
-    ResourceLink,
     TextContent,
 )
 from openai.types.chat import ChatCompletionMessageParam
 
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.helpers.content_helpers import (
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.mcp.helpers.content_helpers import (
     get_image_data,
     get_resource_uri,
     get_text,
@@ -20,13 +20,12 @@ from mcp_agent.mcp.helpers.content_helpers import (
     is_resource_link,
     is_text_content,
 )
-from mcp_agent.mcp.mime_utils import (
+from fast_agent.mcp.mime_utils import (
     guess_mime_type,
     is_image_mime_type,
     is_text_mime_type,
 )
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.mcp.resource_utils import extract_title_from_uri
+from fast_agent.types import PromptMessageExtended
 
 _logger = get_logger("multipart_converter_openai")
 
@@ -55,39 +54,111 @@ class OpenAIConverter:
 
     @staticmethod
     def convert_to_openai(
-        multipart_msg: PromptMessageMultipart, concatenate_text_blocks: bool = False
-    ) -> Dict[str, str | ContentBlock | List[ContentBlock]]:
+        multipart_msg: PromptMessageExtended, concatenate_text_blocks: bool = False
+    ) -> List[Dict[str, Any]]:
         """
-        Convert a PromptMessageMultipart message to OpenAI API format.
+        Convert a PromptMessageExtended message to OpenAI API format.
 
         Args:
-            multipart_msg: The PromptMessageMultipart message to convert
+            multipart_msg: The PromptMessageExtended message to convert
             concatenate_text_blocks: If True, adjacent text blocks will be combined
 
         Returns:
-            An OpenAI API message object
+            A list of OpenAI API message objects
         """
+        # If this is an assistant message that contains tool_calls, convert to an
+        # assistant message with tool_calls per OpenAI format to establish the
+        # required call IDs before tool responses appear.
+        if multipart_msg.role == "assistant" and multipart_msg.tool_calls:
+            tool_calls_list: List[Dict[str, Any]] = []
+            for tool_id, req in multipart_msg.tool_calls.items():
+                name = None
+                arguments = {}
+                try:
+                    params = getattr(req, "params", None)
+                    if params is not None:
+                        name = getattr(params, "name", None)
+                        arguments = getattr(params, "arguments", {}) or {}
+                except Exception:
+                    pass
+
+                tool_calls_list.append(
+                    {
+                        "id": tool_id,
+                        "type": "function",
+                        "function": {
+                            "name": name or "unknown_tool",
+                            "arguments": json.dumps(arguments),
+                        },
+                    }
+                )
+
+            return [{"role": "assistant", "tool_calls": tool_calls_list, "content": ""}]
+
+        # Handle tool_results first if present
+        if multipart_msg.tool_results:
+            messages = OpenAIConverter.convert_function_results_to_openai(
+                multipart_msg.tool_results, concatenate_text_blocks
+            )
+
+            # If there's also content, convert and append it
+            if multipart_msg.content:
+                role = multipart_msg.role
+                content_msg = OpenAIConverter._convert_content_to_message(
+                    multipart_msg.content, role, concatenate_text_blocks
+                )
+                if content_msg:  # Only append if non-empty
+                    messages.append(content_msg)
+
+            return messages
+
+        # Regular content conversion (no tool_results)
         role = multipart_msg.role
+        content_msg = OpenAIConverter._convert_content_to_message(
+            multipart_msg.content, role, concatenate_text_blocks
+        )
+        return [content_msg] if content_msg else []
 
+    @staticmethod
+    def _convert_content_to_message(
+        content: list, role: str, concatenate_text_blocks: bool = False
+    ) -> Dict[str, Any] | None:
+        """
+        Convert content blocks to a single OpenAI message.
+
+        Args:
+            content: List of content blocks
+            role: The message role
+            concatenate_text_blocks: If True, adjacent text blocks will be combined
+
+        Returns:
+            An OpenAI message dict or None if content is empty
+        """
         # Handle empty content
-        if not multipart_msg.content:
+        if not content:
             return {"role": role, "content": ""}
 
         # single text block
-        if 1 == len(multipart_msg.content) and is_text_content(multipart_msg.content[0]):
-            return {"role": role, "content": get_text(multipart_msg.content[0])}
+        if 1 == len(content) and is_text_content(content[0]):
+            return {"role": role, "content": get_text(content[0])}
 
         # For user messages, convert each content block
         content_blocks: List[ContentBlock] = []
 
-        for item in multipart_msg.content:
+        _logger.debug(f"Converting {len(content)} content items for role '{role}'")
+
+        for item in content:
             try:
                 if is_text_content(item):
                     text = get_text(item)
                     content_blocks.append({"type": "text", "text": text})
 
                 elif is_image_content(item):
-                    content_blocks.append(OpenAIConverter._convert_image_content(item))
+                    image_block = OpenAIConverter._convert_image_content(item)
+                    content_blocks.append(image_block)
+                    _logger.debug(
+                        f"Added image content block: {image_block.get('type', 'unknown')}"
+                    )
 
                 elif is_resource_content(item):
                     block = OpenAIConverter._convert_embedded_resource(item)
@@ -95,9 +166,9 @@ class OpenAIConverter:
                         content_blocks.append(block)
 
                 elif is_resource_link(item):
-                    block = OpenAIConverter._convert_resource_link(item)
-                    if block:
-                        content_blocks.append(block)
+                    text = get_text(item)
+                    if text:
+                        content_blocks.append({"type": "text", "text": text})
 
                 else:
                     _logger.warning(f"Unsupported content type: {type(item)}")
@@ -119,7 +190,9 @@ class OpenAIConverter:
             content_blocks = OpenAIConverter._concatenate_text_blocks(content_blocks)
 
         # Return user message with content blocks
-        return {"role": role, "content": content_blocks}
+        result = {"role": role, "content": content_blocks}
+        _logger.debug(f"Final message for role '{role}': {len(content_blocks)} content blocks")
+        return result
 
     @staticmethod
     def _concatenate_text_blocks(blocks: List[ContentBlock]) -> List[ContentBlock]:
@@ -173,11 +246,13 @@ class OpenAIConverter:
         Returns:
             An OpenAI API message object
         """
-        # Convert the PromptMessage to a PromptMessageMultipart containing a single content item
-        multipart = PromptMessageMultipart(role=message.role, content=[message.content])
+        # Convert the PromptMessage to a PromptMessageExtended containing a single content item
+        multipart = PromptMessageExtended(role=message.role, content=[message.content])
 
         # Use the existing conversion method with the specified concatenation option
-        return OpenAIConverter.convert_to_openai(multipart, concatenate_text_blocks)
+        # Since convert_to_openai now returns a list, we return the first element
+        messages = OpenAIConverter.convert_to_openai(multipart, concatenate_text_blocks)
+        return messages[0] if messages else {"role": message.role, "content": ""}
 
     @staticmethod
     def _convert_image_content(content: ImageContent) -> ContentBlock:
@@ -220,32 +295,6 @@ class OpenAIConverter:
 
         return "text/plain"
 
-    @staticmethod
-    def _convert_resource_link(
-        resource: ResourceLink,
-    ) -> Optional[ContentBlock]:
-        """
-        Convert ResourceLink to OpenAI content block.
-
-        Args:
-            resource: The resource link to convert
-
-        Returns:
-            An OpenAI content block or None if conversion failed
-        """
-        name = resource.name or "unknown"
-        uri_str = str(resource.uri)
-        mime_type = resource.mimeType or "unknown"
-        description = resource.description or "No description"
-
-        # Create a text block with the resource link information
-        return {
-            "type": "text",
-            "text": f"Linked Resource ${name} MIME type {mime_type}>\n"
-            f"Resource Link: {uri_str}\n"
-            f"${description}\n",
-        }
-
     @staticmethod
     def _convert_embedded_resource(
         resource: EmbeddedResource,
@@ -263,6 +312,8 @@ class OpenAIConverter:
         uri_str = get_resource_uri(resource)
         uri = getattr(resource_content, "uri", None)
         is_url = uri and str(uri).startswith(("http://", "https://"))
+        from fast_agent.mcp.resource_utils import extract_title_from_uri
+
         title = extract_title_from_uri(uri) if uri else "resource"
         mime_type = OpenAIConverter._determine_mime_type(resource_content)
 
@@ -410,15 +461,16 @@ class OpenAIConverter:
         tool_message_content = ""
         if text_content:
             # Convert text content to OpenAI format
-            temp_multipart = PromptMessageMultipart(role="user", content=text_content)
-            converted = OpenAIConverter.convert_to_openai(
+            temp_multipart = PromptMessageExtended(role="user", content=text_content)
+            converted_messages = OpenAIConverter.convert_to_openai(
                 temp_multipart, concatenate_text_blocks=concatenate_text_blocks
             )
 
-            # Extract text from content blocks
-            tool_message_content = OpenAIConverter._extract_text_from_content_blocks(
-                converted.get("content", "")
-            )
+            # Extract text from content blocks (convert_to_openai now returns a list)
+            if converted_messages:
+                tool_message_content = OpenAIConverter._extract_text_from_content_blocks(
+                    converted_messages[0].get("content", "")
+                )
 
         # Ensure we always have non-empty content for compatibility
         if not tool_message_content or tool_message_content.strip() == "":
@@ -436,23 +488,33 @@ class OpenAIConverter:
             return tool_message
 
         # Process non-text content as a separate user message
-        non_text_multipart = PromptMessageMultipart(role="user", content=non_text_content)
+        non_text_multipart = PromptMessageExtended(role="user", content=non_text_content)
+
+        # Convert to OpenAI format (returns a list now)
+        user_messages = OpenAIConverter.convert_to_openai(non_text_multipart)
 
-        # Convert to OpenAI format
-        user_message = OpenAIConverter.convert_to_openai(non_text_multipart)
+        # Debug logging to understand what's happening with image conversion
+        _logger.debug(
+            f"Tool result conversion: non_text_content={len(non_text_content)} items, "
+            f"user_messages={len(user_messages)} messages"
+        )
+        if not user_messages:
+            _logger.warning(
+                f"No user messages generated for non-text content: {[type(item).__name__ for item in non_text_content]}"
+            )
 
-        return (tool_message, [user_message])
+        return (tool_message, user_messages)
 
     @staticmethod
     def convert_function_results_to_openai(
-        results: List[Tuple[str, CallToolResult]],
+        results: Dict[str, CallToolResult],
         concatenate_text_blocks: bool = False,
     ) -> List[Dict[str, Any]]:
         """
-        Convert a list of function call results to OpenAI messages.
+        Convert function call results to OpenAI messages.
 
         Args:
-            results: List of (tool_call_id, result) tuples
+            results: Dictionary mapping tool_call_id to CallToolResult
             concatenate_text_blocks: If True, adjacent text blocks will be combined
 
         Returns:
@@ -462,7 +524,7 @@ class OpenAIConverter:
         user_messages = []
         has_mixed_content = False
 
-        for tool_call_id, result in results:
+        for tool_call_id, result in results.items():
             try:
                 converted = OpenAIConverter.convert_tool_result_to_openai(
                     tool_result=result,

{mcp_agent/llm/providers → fast_agent/llm/provider/openai}/openai_multipart.py

@@ -1,6 +1,6 @@
 # openai_multipart.py
 """
-Clean utilities for converting between PromptMessageMultipart and OpenAI message formats.
+Clean utilities for converting between PromptMessageExtended and OpenAI message formats.
 Each function handles all content types consistently and is designed for simple testing.
 """
 
@@ -18,34 +18,34 @@ from openai.types.chat import (
     ChatCompletionMessageParam,
 )
 
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.types import PromptMessageExtended
 
 
-def openai_to_multipart(
+def openai_to_extended(
     message: Union[
         ChatCompletionMessage,
         ChatCompletionMessageParam,
         List[Union[ChatCompletionMessage, ChatCompletionMessageParam]],
     ],
-) -> Union[PromptMessageMultipart, List[PromptMessageMultipart]]:
+) -> Union[PromptMessageExtended, List[PromptMessageExtended]]:
     """
-    Convert OpenAI messages to PromptMessageMultipart format.
+    Convert OpenAI messages to PromptMessageExtended format.
 
     Args:
         message: OpenAI Message, MessageParam, or list of them
 
     Returns:
-        Equivalent message(s) in PromptMessageMultipart format
+        Equivalent message(s) in PromptMessageExtended format
     """
     if isinstance(message, list):
-        return [_openai_message_to_multipart(m) for m in message]
-    return _openai_message_to_multipart(message)
+        return [_openai_message_to_extended(m) for m in message]
+    return _openai_message_to_extended(message)
 
 
-def _openai_message_to_multipart(
+def _openai_message_to_extended(
     message: Union[ChatCompletionMessage, Dict[str, Any]],
-) -> PromptMessageMultipart:
-    """Convert a single OpenAI message to PromptMessageMultipart."""
+) -> PromptMessageExtended:
+    """Convert a single OpenAI message to PromptMessageExtended."""
     # Get role and content from message
     if isinstance(message, dict):
         role = message.get("role", "assistant")
@@ -166,4 +166,4 @@ def _openai_message_to_multipart(
                                 )
                             )
 
-    return PromptMessageMultipart(role=role, content=mcp_contents)
+    return PromptMessageExtended(role=role, content=mcp_contents)

{mcp_agent/llm/providers → fast_agent/llm/provider/openai}/openai_utils.py

@@ -12,54 +12,56 @@ from openai.types.chat import (
     ChatCompletionMessageParam,
 )
 
-from mcp_agent.llm.providers.multipart_converter_openai import OpenAIConverter
-from mcp_agent.llm.providers.openai_multipart import (
-    openai_to_multipart,
+from fast_agent.llm.provider.openai.multipart_converter_openai import OpenAIConverter
+from fast_agent.llm.provider.openai.openai_multipart import (
+    openai_to_extended,
 )
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.types import PromptMessageExtended
 
 
 def openai_message_to_prompt_message_multipart(
     message: Union[ChatCompletionMessage, Dict[str, Any]],
-) -> PromptMessageMultipart:
+) -> PromptMessageExtended:
     """
-    Convert an OpenAI ChatCompletionMessage to a PromptMessageMultipart.
+    Convert an OpenAI ChatCompletionMessage to a PromptMessageExtended.
 
     Args:
         message: The OpenAI message to convert (can be an actual ChatCompletionMessage
                 or a dictionary with the same structure)
 
     Returns:
-        A PromptMessageMultipart representation
+        A PromptMessageExtended representation
     """
-    return openai_to_multipart(message)
+    return openai_to_extended(message)
 
 
 def openai_message_param_to_prompt_message_multipart(
     message_param: ChatCompletionMessageParam,
-) -> PromptMessageMultipart:
+) -> PromptMessageExtended:
     """
-    Convert an OpenAI ChatCompletionMessageParam to a PromptMessageMultipart.
+    Convert an OpenAI ChatCompletionMessageParam to a PromptMessageExtended.
 
     Args:
         message_param: The OpenAI message param to convert
 
     Returns:
-        A PromptMessageMultipart representation
+        A PromptMessageExtended representation
     """
-    return openai_to_multipart(message_param)
+    return openai_to_extended(message_param)
 
 
 def prompt_message_multipart_to_openai_message_param(
-    multipart: PromptMessageMultipart,
+    multipart: PromptMessageExtended,
 ) -> ChatCompletionMessageParam:
     """
-    Convert a PromptMessageMultipart to an OpenAI ChatCompletionMessageParam.
+    Convert a PromptMessageExtended to an OpenAI ChatCompletionMessageParam.
 
     Args:
-        multipart: The PromptMessageMultipart to convert
+        multipart: The PromptMessageExtended to convert
 
     Returns:
         An OpenAI ChatCompletionMessageParam representation
     """
-    return OpenAIConverter.convert_to_openai(multipart)
+    # convert_to_openai now returns a list, return the first element for backward compatibility
+    messages = OpenAIConverter.convert_to_openai(multipart)
+    return messages[0] if messages else {"role": multipart.role, "content": ""}

{mcp_agent → fast_agent}/llm/provider_key_manager.py

@@ -8,7 +8,7 @@ from typing import Any, Dict
 
 from pydantic import BaseModel
 
-from mcp_agent.core.exceptions import ProviderKeyError
+from fast_agent.core.exceptions import ProviderKeyError
 
 PROVIDER_ENVIRONMENT_MAP: Dict[str, str] = {
     # default behaviour in _get_env_key_name is to capitalize the
@@ -62,7 +62,7 @@ class ProviderKeyManager:
             ProviderKeyError: If the API key is not found or is invalid
         """
 
-        from mcp_agent.llm.provider_types import Provider
+        from fast_agent.llm.provider_types import Provider
 
         provider_name = provider_name.lower()
 

{mcp_agent → fast_agent}/llm/provider_types.py

@@ -8,6 +8,8 @@ from enum import Enum
 class Provider(Enum):
     """Supported LLM providers"""
 
+    display_name: str
+
     def __new__(cls, config_name, display_name=None):
         obj = object.__new__(cls)
         obj._value_ = config_name

{mcp_agent → fast_agent}/llm/sampling_converter.py

@@ -1,5 +1,5 @@
 """
-Simplified converter between MCP sampling types and PromptMessageMultipart.
+Simplified converter between MCP sampling types and PromptMessageExtended.
 This replaces the more complex provider-specific converters with direct conversions.
 """
 
@@ -12,8 +12,8 @@ from mcp.types import (
     TextContent,
 )
 
-from mcp_agent.mcp.interfaces import RequestParams
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.types import PromptMessageExtended, RequestParams
+from fast_agent.types.llm_stop_reason import LlmStopReason
 
 
 class SamplingConverter:
@@ -21,7 +21,7 @@ class SamplingConverter:
     Simplified converter between MCP sampling types and internal LLM types.
 
     This handles converting between:
-    - SamplingMessage and PromptMessageMultipart
+    - SamplingMessage and PromptMessageExtended
     - CreateMessageRequestParams and RequestParams
     - LLM responses and CreateMessageResult
     """
@@ -29,17 +29,17 @@ class SamplingConverter:
     @staticmethod
     def sampling_message_to_prompt_message(
         message: SamplingMessage,
-    ) -> PromptMessageMultipart:
+    ) -> PromptMessageExtended:
         """
-        Convert a SamplingMessage to a PromptMessageMultipart.
+        Convert a SamplingMessage to a PromptMessageExtended.
 
         Args:
             message: MCP SamplingMessage to convert
 
         Returns:
-            PromptMessageMultipart suitable for use with LLMs
+            PromptMessageExtended suitable for use with LLMs
         """
-        return PromptMessageMultipart(role=message.role, content=[message.content])
+        return PromptMessageExtended(role=message.role, content=[message.content])
 
     @staticmethod
     def extract_request_params(params: CreateMessageRequestParams) -> RequestParams:
@@ -77,20 +77,23 @@ class SamplingConverter:
             role="assistant",
             content=TextContent(type="text", text=error_message),
             model=model or "unknown",
-            stopReason="error",
+            stopReason=LlmStopReason.ERROR.value,
         )
 
     @staticmethod
     def convert_messages(
         messages: List[SamplingMessage],
-    ) -> List[PromptMessageMultipart]:
+    ) -> List[PromptMessageExtended]:
         """
-        Convert multiple SamplingMessages to PromptMessageMultipart objects.
+        Convert multiple SamplingMessages to PromptMessageExtended objects.
+
+        This properly combines consecutive messages with the same role into a single
+        multipart message, which is required by APIs like Anthropic.
 
         Args:
             messages: List of SamplingMessages to convert
 
         Returns:
-            List of PromptMessageMultipart objects, each with a single content item
+            List of PromptMessageExtended objects with consecutive same-role messages combined
         """
         return [SamplingConverter.sampling_message_to_prompt_message(msg) for msg in messages]