fast-agent-mcp 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -1,4 +1,4 @@
-from typing import List, Tuple, Type
+from typing import Dict, List
 
 from mcp.types import (
     CallToolRequest,
@@ -16,7 +16,6 @@ from openai.types.chat import (
     ChatCompletionMessageParam,
     ChatCompletionSystemMessageParam,
     ChatCompletionToolParam,
-    ChatCompletionUserMessageParam,
 )
 from pydantic_core import from_json
 from rich.text import Text
@@ -25,11 +24,10 @@ from mcp_agent.core.exceptions import ProviderKeyError
 from mcp_agent.core.prompt import Prompt
 from mcp_agent.llm.augmented_llm import (
     AugmentedLLM,
-    ModelT,
     RequestParams,
 )
 from mcp_agent.llm.provider_types import Provider
-from mcp_agent.llm.providers.multipart_converter_openai import OpenAIConverter
+from mcp_agent.llm.providers.multipart_converter_openai import OpenAIConverter, OpenAIMessage
 from mcp_agent.llm.providers.sampling_converter_openai import (
     OpenAISamplingConverter,
 )
@@ -38,7 +36,7 @@ from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 _logger = get_logger(__name__)
 
-DEFAULT_OPENAI_MODEL = "gpt-4o"
+DEFAULT_OPENAI_MODEL = "gpt-4.1-mini"
 DEFAULT_REASONING_EFFORT = "medium"
 
 
@@ -49,6 +47,17 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
     This implementation uses OpenAI's ChatCompletion as the LLM.
     """
 
+    # OpenAI-specific parameter exclusions
+    OPENAI_EXCLUDE_FIELDS = {
+        AugmentedLLM.PARAM_MESSAGES,
+        AugmentedLLM.PARAM_MODEL,
+        AugmentedLLM.PARAM_MAX_TOKENS,
+        AugmentedLLM.PARAM_SYSTEM_PROMPT,
+        AugmentedLLM.PARAM_PARALLEL_TOOL_CALLS,
+        AugmentedLLM.PARAM_USE_HISTORY,
+        AugmentedLLM.PARAM_MAX_ITERATIONS,
+    }
+
     def __init__(self, provider: Provider = Provider.OPENAI, *args, **kwargs) -> None:
         # Set type_converter before calling super().__init__
         if "type_converter" not in kwargs:
@@ -68,6 +77,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                 self._reasoning_effort = self.context.config.openai.reasoning_effort
 
         # Determine if we're using a reasoning model
+        # TODO -- move this to model capabiltities, add o4.
         chosen_model = self.default_request_params.model if self.default_request_params else None
         self._reasoning = chosen_model and (
             chosen_model.startswith("o3") or chosen_model.startswith("o1")
@@ -92,9 +102,19 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
     def _base_url(self) -> str:
         return self.context.config.openai.base_url if self.context.config.openai else None
 
-    async def generate_internal(
+    def _openai_client(self) -> OpenAI:
+        try:
+            return OpenAI(api_key=self._api_key(), base_url=self._base_url())
+        except AuthenticationError as e:
+            raise ProviderKeyError(
+                "Invalid OpenAI API key",
+                "The configured OpenAI API key was rejected.\n"
+                "Please check that your API key is valid and not expired.",
+            ) from e
+
+    async def _openai_completion(
         self,
-        message,
+        message: OpenAIMessage,
         request_params: RequestParams | None = None,
     ) -> List[TextContent | ImageContent | EmbeddedResource]:
         """
@@ -103,31 +123,18 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         Override this method to use a different LLM.
         """
 
-        try:
-            openai_client = OpenAI(api_key=self._api_key(), base_url=self._base_url())
-            messages: List[ChatCompletionMessageParam] = []
-            params = self.get_request_params(request_params)
-        except AuthenticationError as e:
-            raise ProviderKeyError(
-                "Invalid OpenAI API key",
-                "The configured OpenAI API key was rejected.\n"
-                "Please check that your API key is valid and not expired.",
-            ) from e
+        request_params = self.get_request_params(request_params=request_params)
+
+        responses: List[TextContent | ImageContent | EmbeddedResource] = []
 
-        system_prompt = self.instruction or params.systemPrompt
+        # TODO -- move this in to agent context management / agent group handling
+        messages: List[ChatCompletionMessageParam] = []
+        system_prompt = self.instruction or request_params.systemPrompt
         if system_prompt:
             messages.append(ChatCompletionSystemMessageParam(role="system", content=system_prompt))
 
-        # Always include prompt messages, but only include conversation history
-        # if use_history is True
-        messages.extend(self.history.get(include_history=params.use_history))
-
-        if isinstance(message, str):
-            messages.append(ChatCompletionUserMessageParam(role="user", content=message))
-        elif isinstance(message, list):
-            messages.extend(message)
-        else:
-            messages.append(message)
+        messages.extend(self.history.get(include_completion_history=request_params.use_history))
+        messages.append(message)
 
         response = await self.aggregator.list_tools()
         available_tools: List[ChatCompletionToolParam] | None = [
@@ -135,57 +142,37 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                 type="function",
                 function={
                     "name": tool.name,
-                    "description": tool.description,
+                    "description": tool.description if tool.description else "",
                     "parameters": tool.inputSchema,
-                    # TODO: saqadri - determine if we should specify "strict" to True by default
                 },
             )
             for tool in response.tools
         ]
+
         if not available_tools:
             available_tools = None  # deepseek does not allow empty array
 
-        responses: List[TextContent | ImageContent | EmbeddedResource] = []
-        model = self.default_request_params.model
-
-        # we do NOT send stop sequences as this causes errors with mutlimodal processing
-        for i in range(params.max_iterations):
-            arguments = {
-                "model": model or "gpt-4o",
-                "messages": messages,
-                "tools": available_tools,
-            }
-            if self._reasoning:
-                arguments = {
-                    **arguments,
-                    "max_completion_tokens": params.maxTokens,
-                    "reasoning_effort": self._reasoning_effort,
-                }
-            else:
-                arguments = {**arguments, "max_tokens": params.maxTokens}
-                if available_tools:
-                    arguments["parallel_tool_calls"] = params.parallel_tool_calls
-
-            if params.metadata:
-                arguments = {**arguments, **params.metadata}
+        # we do NOT send "stop sequences" as this causes errors with mutlimodal processing
+        for i in range(request_params.max_iterations):
+            arguments = self._prepare_api_request(messages, available_tools, request_params)
+            self.logger.debug(f"OpenAI completion requested for: {arguments}")
 
-            self.logger.debug(f"{arguments}")
-            self._log_chat_progress(self.chat_turn(), model=model)
+            self._log_chat_progress(self.chat_turn(), model=self.default_request_params.model)
 
             executor_result = await self.executor.execute(
-                openai_client.chat.completions.create, **arguments
+                self._openai_client().chat.completions.create, **arguments
             )
 
             response = executor_result[0]
 
             self.logger.debug(
-                "OpenAI ChatCompletion response:",
+                "OpenAI completion response:",
                 data=response,
             )
 
             if isinstance(response, AuthenticationError):
                 raise ProviderKeyError(
-                    "Invalid OpenAI API key",
+                    "Rejected OpenAI API key",
                     "The configured OpenAI API key was rejected.\n"
                     "Please check that your API key is valid and not expired.",
                 ) from response
@@ -203,8 +190,9 @@ 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, name=self.name)
+            converted_message = self.convert_message_to_message_param(message)
             messages.append(converted_message)
+
             message_text = converted_message.content
             if choice.finish_reason in ["tool_calls", "function_call"] and message.tool_calls:
                 if message_text:
@@ -262,14 +250,12 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                     )
 
                 await self.show_assistant_message(message_text)
-                # TODO: saqadri - would be useful to return the reason for stopping to the caller
                 break
             elif choice.finish_reason == "content_filter":
                 # The response was filtered by the content filter
                 self.logger.debug(
                     f"Iteration {i}: Stopping because finish_reason is 'content_filter'"
                 )
-                # TODO: saqadri - would be useful to return the reason for stopping to the caller
                 break
             elif choice.finish_reason == "stop":
                 self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'stop'")
@@ -277,11 +263,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                     await self.show_assistant_message(message_text, "")
                 break
 
-        # Only save the new conversation messages to history if use_history is true
-        # Keep the prompt messages separate
-        if params.use_history:
+        if request_params.use_history:
             # Get current prompt messages
-            prompt_messages = self.history.get(include_history=False)
+            prompt_messages = self.history.get(include_completion_history=False)
 
             # Calculate new conversation messages (excluding prompts)
             new_messages = messages[len(prompt_messages) :]
@@ -289,7 +273,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             # Update conversation history
             self.history.set(new_messages)
 
-        self._log_chat_finished(model=model)
+        self._log_chat_finished(model=self.default_request_params.model)
 
         return responses
 
@@ -297,111 +281,34 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         self,
         multipart_messages: List["PromptMessageMultipart"],
         request_params: RequestParams | None = None,
+        is_template: bool = False,
     ) -> PromptMessageMultipart:
-        # TODO -- this is very similar to Anthropic (just the converter class changes).
-        # TODO -- potential refactor to base class, standardize Converter interface
-        # Check the last message role
         last_message = multipart_messages[-1]
 
         # Add all previous messages to history (or all messages if last is from assistant)
+        # if the last message is a "user" inference is required
         messages_to_add = (
             multipart_messages[:-1] if last_message.role == "user" else multipart_messages
         )
         converted = []
         for msg in messages_to_add:
             converted.append(OpenAIConverter.convert_to_openai(msg))
-        self.history.extend(converted, is_prompt=True)
-
-        if last_message.role == "user":
-            # For user messages: Generate response to the last one
-            self.logger.debug("Last message in prompt is from user, generating assistant response")
-            message_param = OpenAIConverter.convert_to_openai(last_message)
-            responses: List[
-                TextContent | ImageContent | EmbeddedResource
-            ] = await self.generate_internal(
-                message_param,
-                request_params,
-            )
-            return Prompt.assistant(*responses)
-        else:
-            # For assistant messages: Return the last message content as text
-            self.logger.debug("Last message in prompt is from assistant, returning it directly")
-            return last_message
 
-    async def structured(
-        self,
-        prompt: List[PromptMessageMultipart],
-        model: Type[ModelT],
-        request_params: RequestParams | None = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
-        """
-        Apply the prompt and return the result as a Pydantic model.
-
-        Uses OpenAI's beta parse feature when compatible, falling back to standard
-        JSON parsing if the beta feature fails or is unavailable.
-
-        Args:
-            prompt: List of messages to process
-            model: Pydantic model to parse the response into
-            request_params: Optional request parameters
-
-        Returns:
-            The parsed response as a Pydantic model, or None if parsing fails
-        """
-
-        if not Provider.OPENAI == self.provider:
-            return await super().structured(prompt, model, request_params)
-
-        logger = get_logger(__name__)
-
-        # First try to use OpenAI's beta.chat.completions.parse feature
-        try:
-            # Convert the multipart messages to OpenAI format
-            messages = []
-            for msg in prompt:
-                messages.append(OpenAIConverter.convert_to_openai(msg))
-
-            # Add system prompt if available and not already present
-            if self.instruction and not any(m.get("role") == "system" for m in messages):
-                system_msg = ChatCompletionSystemMessageParam(
-                    role="system", content=self.instruction
-                )
-                messages.insert(0, system_msg)
-            model_name = self.default_request_params.model
-            self.show_user_message(prompt[-1].first_text(), model_name, self.chat_turn())
-            # Use the beta parse feature
-            try:
-                openai_client = OpenAI(api_key=self._api_key(), base_url=self._base_url())
-                model_name = self.default_request_params.model
-
-                logger.debug(
-                    f"Using OpenAI beta parse with model {model_name} for structured output"
-                )
-                response = await self.executor.execute(
-                    openai_client.beta.chat.completions.parse,
-                    model=model_name,
-                    messages=messages,
-                    response_format=model,
-                )
-
-                if response and isinstance(response[0], BaseException):
-                    raise response[0]
-                parsed_result = response[0].choices[0].message
-                await self.show_assistant_message(parsed_result.content)
-                logger.debug("Successfully used OpenAI beta parse feature for structured output")
-                return parsed_result.parsed, Prompt.assistant(parsed_result.content)
+        # TODO -- this looks like a defect from previous apply_prompt implementation.
+        self.history.extend(converted, is_prompt=is_template)
 
-            except (ImportError, AttributeError, NotImplementedError) as e:
-                # Beta feature not available, log and continue to fallback
-                logger.debug(f"OpenAI beta parse feature not available: {str(e)}")
-                # Continue to fallback
-
-        except Exception as e:
-            logger.debug(f"OpenAI beta parse failed: {str(e)}, falling back to standard method")
-            # Continue to standard method as fallback
+        if "assistant" == last_message.role:
+            return last_message
 
-        # Fallback to standard method (inheriting from base class)
-        return await super().structured(prompt, model, request_params)
+        # For assistant messages: Return the last message (no completion needed)
+        message_param: OpenAIMessage = OpenAIConverter.convert_to_openai(last_message)
+        responses: List[
+            TextContent | ImageContent | EmbeddedResource
+        ] = await self._openai_completion(
+            message_param,
+            request_params,
+        )
+        return Prompt.assistant(*responses)
 
     async def pre_tool_call(self, tool_call_id: str | None, request: CallToolRequest):
         return request
@@ -410,3 +317,33 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         self, tool_call_id: str | None, request: CallToolRequest, result: CallToolResult
     ):
         return result
+
+    def _prepare_api_request(
+        self, messages, tools, request_params: RequestParams
+    ) -> dict[str, str]:
+        # Create base arguments dictionary
+
+        # overriding model via request params not supported (intentional)
+        base_args = {
+            "model": self.default_request_params.model,
+            "messages": messages,
+            "tools": tools,
+        }
+
+        if self._reasoning:
+            base_args.update(
+                {
+                    "max_completion_tokens": request_params.maxTokens,
+                    "reasoning_effort": self._reasoning_effort,
+                }
+            )
+        else:
+            base_args["max_tokens"] = request_params.maxTokens
+
+        if tools:
+            base_args["parallel_tool_calls"] = request_params.parallel_tool_calls
+
+        arguments: Dict[str, str] = self.prepare_provider_arguments(
+            base_args, request_params, self.OPENAI_EXCLUDE_FIELDS.union(self.BASE_EXCLUDE_FIELDS)
+        )
+        return arguments

mcp_agent/llm/providers/multipart_converter_openai.py

@@ -7,6 +7,7 @@ from mcp.types import (
     PromptMessage,
     TextContent,
 )
+from openai.types.chat import ChatCompletionMessageParam
 
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.helpers.content_helpers import (
@@ -23,7 +24,6 @@ from mcp_agent.mcp.mime_utils import (
     is_text_mime_type,
 )
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.mcp.prompts.prompt_helpers import MessageContent
 from mcp_agent.mcp.resource_utils import extract_title_from_uri
 
 _logger = get_logger("multipart_converter_openai")
@@ -54,7 +54,7 @@ class OpenAIConverter:
     @staticmethod
     def convert_to_openai(
         multipart_msg: PromptMessageMultipart, concatenate_text_blocks: bool = False
-    ) -> OpenAIMessage:
+    ) -> Dict[str, str | ContentBlock | List[ContentBlock]]:
         """
         Convert a PromptMessageMultipart message to OpenAI API format.
 
@@ -71,11 +71,9 @@ class OpenAIConverter:
         if not multipart_msg.content:
             return {"role": role, "content": ""}
 
-        # Assistant and system messages in OpenAI only support string content, not array of content blocks
-        if role == "assistant" or role == "system":
-            # Use MessageContent helper to get all text
-            content_text = MessageContent.join_text(multipart_msg, separator="")
-            return {"role": role, "content": content_text}
+        # 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])}
 
         # For user messages, convert each content block
         content_blocks: List[ContentBlock] = []
@@ -94,12 +92,6 @@ class OpenAIConverter:
                     if block:
                         content_blocks.append(block)
 
-                # Handle input_audio if implemented
-                elif hasattr(item, "type") and getattr(item, "type") == "input_audio":
-                    _logger.warning("Input audio content not supported in standard OpenAI types")
-                    fallback_text = "[Audio content not directly supported]"
-                    content_blocks.append({"type": "text", "text": fallback_text})
-
                 else:
                     _logger.warning(f"Unsupported content type: {type(item)}")
                     # Create a text block with information about the skipped content
@@ -112,18 +104,9 @@ class OpenAIConverter:
                 fallback_text = f"[Content conversion error: {str(e)}]"
                 content_blocks.append({"type": "text", "text": fallback_text})
 
-        # Special case: empty content list or only empty text blocks
         if not content_blocks:
             return {"role": role, "content": ""}
 
-        # If we only have one text content and it's empty, return an empty string for content
-        if (
-            len(content_blocks) == 1
-            and content_blocks[0]["type"] == "text"
-            and not content_blocks[0]["text"]
-        ):
-            return {"role": role, "content": ""}
-
         # If concatenate_text_blocks is True, combine adjacent text blocks
         if concatenate_text_blocks:
             content_blocks = OpenAIConverter._concatenate_text_blocks(content_blocks)
@@ -172,7 +155,7 @@ class OpenAIConverter:
     @staticmethod
     def convert_prompt_message_to_openai(
         message: PromptMessage, concatenate_text_blocks: bool = False
-    ) -> OpenAIMessage:
+    ) -> ChatCompletionMessageParam:
         """
         Convert a standard PromptMessage to OpenAI API format.
 
@@ -194,7 +177,7 @@ class OpenAIConverter:
         """Convert ImageContent to OpenAI image_url content block."""
         # Get image data using helper
         image_data = get_image_data(content)
-        
+
         # OpenAI requires image URLs or data URIs for images
         image_url = {"url": f"data:{content.mimeType};base64,{image_data}"}
 
@@ -256,8 +239,8 @@ class OpenAIConverter:
         if OpenAIConverter._is_supported_image_type(mime_type):
             if is_url and uri_str:
                 return {"type": "image_url", "image_url": {"url": uri_str}}
-            
-            # Try to get image data 
+
+            # Try to get image data
             image_data = get_image_data(resource)
             if image_data:
                 return {
@@ -462,4 +445,4 @@ class OpenAIConverter:
                 # Single message case (text-only)
                 messages.append(converted)
 
-        return messages
+        return messages

mcp_agent/llm/providers/sampling_converter_openai.py

@@ -1,11 +1,8 @@
-from typing import Any, Dict
 
 from mcp.types import (
     PromptMessage,
 )
-from openai.types.chat import (
-    ChatCompletionMessage,
-)
+from openai.types.chat import ChatCompletionMessage, ChatCompletionMessageParam
 
 from mcp_agent.llm.sampling_format_converter import (
     ProviderFormatConverter,
@@ -15,9 +12,11 @@ from mcp_agent.logging.logger import get_logger
 _logger = get_logger(__name__)
 
 
-class OpenAISamplingConverter(ProviderFormatConverter[Dict[str, Any], ChatCompletionMessage]):
+class OpenAISamplingConverter(
+    ProviderFormatConverter[ChatCompletionMessageParam, ChatCompletionMessage]
+):
     @classmethod
-    def from_prompt_message(cls, message: PromptMessage) -> Dict[str, Any]:
+    def from_prompt_message(cls, message: PromptMessage) -> ChatCompletionMessageParam:
         """Convert an MCP PromptMessage to an OpenAI message dict."""
         from mcp_agent.llm.providers.multipart_converter_openai import (
             OpenAIConverter,

mcp_agent/mcp/interfaces.py

@@ -20,6 +20,7 @@ from typing import (
     runtime_checkable,
 )
 
+from a2a_types.types import AgentCard
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from deprecated import deprecated
 from mcp import ClientSession
@@ -96,7 +97,7 @@ class AugmentedLLMProtocol(Protocol):
 
     async def structured(
         self,
-        prompt: List[PromptMessageMultipart],
+        multipart_messages: List[PromptMessageMultipart],
         model: Type[ModelT],
         request_params: RequestParams | None = None,
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:
@@ -190,6 +191,10 @@ class AgentProtocol(AugmentedLLMProtocol, Protocol):
         """Send a message with an attached MCP resource"""
         ...
 
+    async def agent_card(self) -> AgentCard:
+        """Return an A2A Agent Card for this Agent"""
+        ...
+
     async def initialize(self) -> None:
         """Initialize the agent and connect to MCP servers"""
         ...

mcp_agent/mcp/mcp_aggregator.py

@@ -482,7 +482,7 @@ class MCPAggregator(ContextDependent):
 
     async def get_prompt(
         self,
-        prompt_name: str | None,
+        prompt_name: str,
         arguments: dict[str, str] | None = None,
         server_name: str | None = None,
     ) -> GetPromptResult:
@@ -502,13 +502,7 @@ class MCPAggregator(ContextDependent):
             await self.load_servers()
 
         # Handle the case where prompt_name is None
-        if not prompt_name:
-            if server_name is None:
-                server_name = self.server_names[0] if self.server_names else None
-            local_prompt_name = None
-            namespaced_name = None
-        # Handle namespaced prompt name
-        elif SEP in prompt_name and server_name is None:
+        if SEP in prompt_name and server_name is None:
             server_name, local_prompt_name = prompt_name.split(SEP, 1)
             namespaced_name = prompt_name  # Already namespaced
         # Plain prompt name - use provided server or search

mcp_agent/mcp/prompt_message_multipart.py

@@ -58,7 +58,7 @@ class PromptMessageMultipart(BaseModel):
 
     def first_text(self) -> str:
         """
-        Get the first available text content from a message.
+        Get the first available text content from a message. Note this could be tool content etc.
 
         Args:
             message: A PromptMessage or PromptMessageMultipart
@@ -73,6 +73,24 @@ class PromptMessageMultipart(BaseModel):
 
         return "<no text>"
 
+    def last_text(self) -> str:
+        """
+        Get the last available text content from a message. This will usually be the final
+        generation from the Assistant.
+
+        Args:
+            message: A PromptMessage or PromptMessageMultipart
+
+        Returns:
+            First text content or None if no text content exists
+        """
+        for content in reversed(self.content):
+            text = get_text(content)
+            if text is not None:
+                return text
+
+        return "<no text>"
+
     def all_text(self) -> str:
         """
         Get all the text available.
@@ -91,6 +109,11 @@ class PromptMessageMultipart(BaseModel):
 
         return "\n".join(result)
 
+    def add_text(self, to_add: str) -> TextContent:
+        text = TextContent(type="text", text=to_add)
+        self.content.append(text)
+        return text
+
     @classmethod
     def parse_get_prompt_result(cls, result: GetPromptResult) -> List["PromptMessageMultipart"]:
         """
@@ -120,4 +143,4 @@ class PromptMessageMultipart(BaseModel):
         """
         if not result or not result.messages:
             return []
-        return cls.to_multipart(result.messages)
+        return cls.to_multipart(result.messages)

mcp_agent/resources/examples/data-analysis/analysis-campaign.py

@@ -33,7 +33,7 @@ Extract key insights that would be compelling for a social media campaign.
      - Extracted compelling insights suitable for social media promotion
     """,
     request_params=RequestParams(maxTokens=8192),
-    model="gpt-4o",
+    model="gpt-4.1",
 )
 @fast.evaluator_optimizer(
     "analysis_tool",
@@ -55,7 +55,7 @@ Extract key insights that would be compelling for a social media campaign.
     """,
     servers=["fetch", "brave"],  # Using the fetch MCP server for Brave search
     request_params=RequestParams(temperature=0.3),
-    model="gpt-4o",
+    model="gpt-4.1",
 )
 # Social media content generator
 @fast.agent(

mcp_agent/resources/examples/in_dev/agent_build.py

@@ -61,7 +61,7 @@ if needed. Remind the Human of this.
     model="sonnet",
     plan_type="iterative",
     request_params=RequestParams(maxTokens=8192),
-    max_iterations=5,
+    plan_iterations=5,
 )
 async def main() -> None:
     async with fast.run() as agent:

mcp_agent/resources/examples/internal/job.py

@@ -42,7 +42,7 @@ fast = FastAgent("PMO Job Description Generator")
     6. Emphasis on practical experience over formal requirements                                         
                                                                                                         
     Provide specific feedback for improvements.""",
-    model="gpt-4o",
+    model="gpt-4.1",
 )
 @fast.agent(
     name="file_handler",