fast-agent-mcp 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

mcp_agent/core/exceptions.py

@@ -7,7 +7,7 @@ Enables user-friendly error handling for common issues.
 class FastAgentError(Exception):
     """Base exception class for FastAgent errors"""
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         self.message = message
         self.details = details
         super().__init__(f"{message}\n\n{details}" if details else message)
@@ -18,7 +18,7 @@ class ServerConfigError(FastAgentError):
     Example: Server name referenced in agent.servers[] but not defined in config
     """
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
@@ -27,7 +27,7 @@ class AgentConfigError(FastAgentError):
     Example: Parallel fan-in references unknown agent
     """
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
@@ -36,14 +36,14 @@ class ProviderKeyError(FastAgentError):
     Example: OpenAI/Anthropic key not configured but model requires it
     """
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
 class ServerInitializationError(FastAgentError):
     """Raised when a server fails to initialize properly."""
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
@@ -52,14 +52,14 @@ class ModelConfigError(FastAgentError):
     Example: Unknown model name in model specification string
     """
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
 class CircularDependencyError(FastAgentError):
     """Raised when we detect a Circular Dependency in the workflow"""
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
@@ -67,5 +67,5 @@ class PromptExitError(FastAgentError):
     """Raised from enhanced_prompt when the user requests hard exits"""
 
     # TODO an exception for flow control :(
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)

mcp_agent/core/factory.py

@@ -2,11 +2,22 @@
 Factory functions for creating agent and workflow instances.
 """
 
-from typing import Dict, Any, Optional, TypeVar, Callable
+from typing import Any, Callable, Dict, Optional, TypeVar
 
-from mcp_agent.app import MCPApp
 from mcp_agent.agents.agent import Agent
+from mcp_agent.app import MCPApp
 from mcp_agent.core.agent_types import AgentConfig, AgentType
+from mcp_agent.core.agent_utils import get_agent_instances, log_agent_load, unwrap_proxy
+from mcp_agent.core.exceptions import AgentConfigError
+from mcp_agent.core.proxies import (
+    BaseAgentProxy,
+    ChainProxy,
+    LLMAgentProxy,
+    RouterProxy,
+    WorkflowProxy,
+)
+from mcp_agent.core.types import AgentOrWorkflow, ProxyDict
+from mcp_agent.core.validation import get_dependencies
 from mcp_agent.event_progress import ProgressAction
 from mcp_agent.workflows.evaluator_optimizer.evaluator_optimizer import (
     EvaluatorOptimizerLLM,
@@ -17,24 +28,11 @@ from mcp_agent.workflows.llm.model_factory import ModelFactory
 from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
 from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
 from mcp_agent.workflows.router.router_llm import LLMRouter
-from mcp_agent.core.exceptions import AgentConfigError
-from mcp_agent.core.proxies import (
-    BaseAgentProxy,
-    LLMAgentProxy,
-    WorkflowProxy,
-    RouterProxy,
-    ChainProxy,
-)
-from mcp_agent.core.types import AgentOrWorkflow, ProxyDict
-from mcp_agent.core.agent_utils import log_agent_load, unwrap_proxy, get_agent_instances
-from mcp_agent.core.validation import get_dependencies
 
 T = TypeVar("T")  # For the wrapper classes
 
 
-def create_proxy(
-    app: MCPApp, name: str, instance: AgentOrWorkflow, agent_type: str
-) -> BaseAgentProxy:
+def create_proxy(app: MCPApp, name: str, instance: AgentOrWorkflow, agent_type: str) -> BaseAgentProxy:
     """Create appropriate proxy type based on agent type and validate instance type
 
     Args:
@@ -61,27 +59,19 @@ def create_proxy(
         return LLMAgentProxy(app, name, instance)
     elif agent_type == AgentType.ORCHESTRATOR.value:
         if not isinstance(instance, Orchestrator):
-            raise TypeError(
-                f"Expected Orchestrator instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected Orchestrator instance for {name}, got {type(instance)}")
         return WorkflowProxy(app, name, instance)
     elif agent_type == AgentType.PARALLEL.value:
         if not isinstance(instance, ParallelLLM):
-            raise TypeError(
-                f"Expected ParallelLLM instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected ParallelLLM instance for {name}, got {type(instance)}")
         return WorkflowProxy(app, name, instance)
     elif agent_type == AgentType.EVALUATOR_OPTIMIZER.value:
         if not isinstance(instance, EvaluatorOptimizerLLM):
-            raise TypeError(
-                f"Expected EvaluatorOptimizerLLM instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected EvaluatorOptimizerLLM instance for {name}, got {type(instance)}")
         return WorkflowProxy(app, name, instance)
     elif agent_type == AgentType.ROUTER.value:
         if not isinstance(instance, LLMRouter):
-            raise TypeError(
-                f"Expected LLMRouter instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected LLMRouter instance for {name}, got {type(instance)}")
         return RouterProxy(app, name, instance)
     elif agent_type == AgentType.CHAIN.value:
         # Chain proxy is directly returned from _create_agents_by_type
@@ -187,11 +177,7 @@ async def create_agents_by_type(
 
             elif agent_type == AgentType.ORCHESTRATOR:
                 # Get base params configured with model settings
-                base_params = (
-                    config.default_request_params.model_copy()
-                    if config.default_request_params
-                    else RequestParams()
-                )
+                base_params = config.default_request_params.model_copy() if config.default_request_params else RequestParams()
                 base_params.use_history = False  # Force no history for orchestrator
 
                 # Get the child agents - need to unwrap proxies and validate LLM config
@@ -231,7 +217,6 @@ async def create_agents_by_type(
                 )
 
                 planner = await planner_agent.attach_llm(planner_factory)
-                await planner.initialize()
                 # Create the orchestrator with pre-configured planner
                 instance = Orchestrator(
                     name=config.name,
@@ -239,9 +224,7 @@ async def create_agents_by_type(
                     available_agents=child_agents,
                     context=app_instance.context,
                     request_params=planner.default_request_params,  # Base params already include model settings
-                    plan_type=agent_data.get(
-                        "plan_type", "full"
-                    ),  # Get plan_type from agent_data
+                    plan_type=agent_data.get("plan_type", "full"),  # Get plan_type from agent_data
                     verb=ProgressAction.PLANNING,
                 )
 
@@ -251,19 +234,13 @@ async def create_agents_by_type(
                 evaluator = unwrap_proxy(active_agents[agent_data["evaluator"]])
 
                 if not generator or not evaluator:
-                    raise ValueError(
-                        f"Missing agents for workflow {name}: "
-                        f"generator={agent_data['generator']}, "
-                        f"evaluator={agent_data['evaluator']}"
-                    )
+                    raise ValueError(f"Missing agents for workflow {name}: generator={agent_data['generator']}, evaluator={agent_data['evaluator']}")
 
                 # Get model from generator if it's an Agent, or from config otherwise
                 optimizer_model = None
                 if isinstance(generator, Agent):
                     optimizer_model = generator.config.model
-                elif hasattr(generator, "_sequence") and hasattr(
-                    generator, "_agent_proxies"
-                ):
+                elif hasattr(generator, "_sequence") and hasattr(generator, "_agent_proxies"):
                     # For ChainProxy, use the config model directly
                     optimizer_model = config.model
 
@@ -328,27 +305,19 @@ async def create_agents_by_type(
 
                     # Generate a better description
                     if agent_names:
-                        server_part = (
-                            f" with access to servers: {', '.join(sorted(all_servers))}"
-                            if all_servers
-                            else ""
-                        )
+                        server_part = f" with access to servers: {', '.join(sorted(all_servers))}" if all_servers else ""
                         config.instruction = f"Sequence of agents: {', '.join(agent_names)}{server_part}."
 
                 # Create a ChainProxy without needing a new instance
                 # Just pass the agent proxies and sequence
                 instance = ChainProxy(app_instance, name, sequence, active_agents)
                 # Set continue_with_final behavior from configuration
-                instance._continue_with_final = agent_data.get(
-                    "continue_with_final", True
-                )
+                instance._continue_with_final = agent_data.get("continue_with_final", True)
                 # Set cumulative behavior from configuration
                 instance._cumulative = agent_data.get("cumulative", False)
 
             elif agent_type == AgentType.PARALLEL:
-                fan_out_agents = get_agent_instances(
-                    agent_data["fan_out"], active_agents
-                )
+                fan_out_agents = get_agent_instances(agent_data["fan_out"], active_agents)
 
                 # Get fan-in agent - unwrap proxy
                 fan_in_agent = unwrap_proxy(active_agents[agent_data["fan_in"]])
@@ -370,9 +339,7 @@ async def create_agents_by_type(
                 raise ValueError(f"Unsupported agent type: {agent_type}")
 
             # Create the appropriate proxy and store in results
-            result_agents[name] = create_proxy(
-                app_instance, name, instance, agent_type.value
-            )
+            result_agents[name] = create_proxy(app_instance, name, instance, agent_type.value)
 
     return result_agents
 
@@ -426,24 +393,16 @@ async def create_agents_in_dependency_order(
     visited = set()
 
     # Get all agents of the specified type
-    agent_names = [
-        name
-        for name, agent_data in agents_dict.items()
-        if agent_data["type"] == agent_type.value
-    ]
+    agent_names = [name for name, agent_data in agents_dict.items() if agent_data["type"] == agent_type.value]
 
     # Create agents in dependency order
     for name in agent_names:
         # Get ordered dependencies if not already processed
         if name not in visited:
             try:
-                ordered_agents = get_dependencies(
-                    name, agents_dict, visited, set(), agent_type
-                )
+                ordered_agents = get_dependencies(name, agents_dict, visited, set(), agent_type)
             except ValueError as e:
-                raise ValueError(
-                    f"Error creating {agent_type.name.lower()} agent {name}: {str(e)}"
-                )
+                raise ValueError(f"Error creating {agent_type.name.lower()} agent {name}: {str(e)}")
 
             # Create each agent in order
             for agent_name in ordered_agents:

mcp_agent/core/fastagent.py

@@ -3,61 +3,59 @@ Decorator-based interface for MCP Agent applications.
 Provides a simplified way to create and manage agents using decorators.
 """
 
+import argparse
 import asyncio
+from contextlib import asynccontextmanager
+from functools import partial
 from typing import (
-    Optional,
+    Any,
     Dict,
+    Optional,
     TypeVar,
-    Any,
 )
+
 import yaml
-import argparse
-from contextlib import asynccontextmanager
-from functools import partial
+
+# TODO -- reinstate once Windows&Python 3.13 platform issues are fixed
+# import readline  # noqa: F401
+from rich import print
 
 from mcp_agent.app import MCPApp
 from mcp_agent.config import Settings
-
 from mcp_agent.core.agent_app import AgentApp
 from mcp_agent.core.agent_types import AgentType
+from mcp_agent.core.decorators import (
+    _create_decorator,
+    agent,
+    chain,
+    evaluator_optimizer,
+    orchestrator,
+    parallel,
+    passthrough,
+    router,
+)
 from mcp_agent.core.error_handling import handle_error
-from mcp_agent.core.proxies import LLMAgentProxy
-from mcp_agent.core.types import ProxyDict
 from mcp_agent.core.exceptions import (
     AgentConfigError,
     CircularDependencyError,
     ModelConfigError,
     PromptExitError,
-    ServerConfigError,
     ProviderKeyError,
+    ServerConfigError,
     ServerInitializationError,
 )
-from mcp_agent.core.decorators import (
-    _create_decorator,
-    agent,
-    orchestrator,
-    parallel,
-    evaluator_optimizer,
-    router,
-    chain,
-    passthrough,
+from mcp_agent.core.factory import (
+    create_agents_by_type,
+    create_agents_in_dependency_order,
+    create_basic_agents,
+    get_model_factory,
 )
+from mcp_agent.core.proxies import LLMAgentProxy
+from mcp_agent.core.types import ProxyDict
 from mcp_agent.core.validation import (
     validate_server_references,
     validate_workflow_references,
 )
-from mcp_agent.core.factory import (
-    get_model_factory,
-    create_basic_agents,
-    create_agents_in_dependency_order,
-    create_agents_by_type,
-)
-
-# TODO -- reinstate once Windows&Python 3.13 platform issues are fixed
-# import readline  # noqa: F401
-
-from rich import print
-
 from mcp_agent.mcp_server import AgentMCPServer
 
 T = TypeVar("T")  # For the wrapper classes
@@ -74,7 +72,7 @@ class FastAgent:
         name: str,
         config_path: Optional[str] = None,
         ignore_unknown_args: bool = False,
-    ):
+    ) -> None:
         """
         Initialize the decorator interface.
 
@@ -218,9 +216,7 @@ class FastAgent:
         model_factory_func = partial(self._get_model_factory)
         return await create_basic_agents(agent_app, self.agents, model_factory_func)
 
-    async def _create_orchestrators(
-        self, agent_app: MCPApp, active_agents: ProxyDict
-    ) -> ProxyDict:
+    async def _create_orchestrators(self, agent_app: MCPApp, active_agents: ProxyDict) -> ProxyDict:
         """
         Create orchestrator agents.
 
@@ -231,13 +227,9 @@ class FastAgent:
         Returns:
             Dictionary of initialized orchestrator agents wrapped in appropriate proxies
         """
-        return await self._create_agents_by_type(
-            agent_app, AgentType.ORCHESTRATOR, active_agents
-        )
+        return await self._create_agents_by_type(agent_app, AgentType.ORCHESTRATOR, active_agents)
 
-    async def _create_evaluator_optimizers(
-        self, agent_app: MCPApp, active_agents: ProxyDict
-    ) -> ProxyDict:
+    async def _create_evaluator_optimizers(self, agent_app: MCPApp, active_agents: ProxyDict) -> ProxyDict:
         """
         Create evaluator-optimizer workflows.
 
@@ -248,13 +240,9 @@ class FastAgent:
         Returns:
             Dictionary of initialized evaluator-optimizer workflows
         """
-        return await self._create_agents_by_type(
-            agent_app, AgentType.EVALUATOR_OPTIMIZER, active_agents
-        )
+        return await self._create_agents_by_type(agent_app, AgentType.EVALUATOR_OPTIMIZER, active_agents)
 
-    async def _create_parallel_agents(
-        self, agent_app: MCPApp, active_agents: ProxyDict
-    ) -> ProxyDict:
+    async def _create_parallel_agents(self, agent_app: MCPApp, active_agents: ProxyDict) -> ProxyDict:
         """
         Create parallel execution agents in dependency order.
 
@@ -274,9 +262,7 @@ class FastAgent:
             model_factory_func,
         )
 
-    async def _create_agents_in_dependency_order(
-        self, agent_app: MCPApp, active_agents: ProxyDict, agent_type: AgentType
-    ) -> ProxyDict:
+    async def _create_agents_in_dependency_order(self, agent_app: MCPApp, active_agents: ProxyDict, agent_type: AgentType) -> ProxyDict:
         """
         Create agents in dependency order to avoid circular references.
         Works for both Parallel and Chain workflows.
@@ -290,13 +276,9 @@ class FastAgent:
             Dictionary of initialized agents
         """
         model_factory_func = partial(self._get_model_factory)
-        return await create_agents_in_dependency_order(
-            agent_app, self.agents, active_agents, agent_type, model_factory_func
-        )
+        return await create_agents_in_dependency_order(agent_app, self.agents, active_agents, agent_type, model_factory_func)
 
-    async def _create_routers(
-        self, agent_app: MCPApp, active_agents: ProxyDict
-    ) -> ProxyDict:
+    async def _create_routers(self, agent_app: MCPApp, active_agents: ProxyDict) -> ProxyDict:
         """
         Create router agents.
 
@@ -307,9 +289,7 @@ class FastAgent:
         Returns:
             Dictionary of initialized router agents
         """
-        return await self._create_agents_by_type(
-            agent_app, AgentType.ROUTER, active_agents
-        )
+        return await self._create_agents_by_type(agent_app, AgentType.ROUTER, active_agents)
 
     @asynccontextmanager
     async def run(self):
@@ -327,11 +307,7 @@ class FastAgent:
         try:
             async with self.app.run() as agent_app:
                 # Apply quiet mode directly to the context's config if needed
-                if (
-                    quiet_mode
-                    and hasattr(agent_app.context, "config")
-                    and hasattr(agent_app.context.config, "logger")
-                ):
+                if quiet_mode and hasattr(agent_app.context, "config") and hasattr(agent_app.context.config, "logger"):
                     # Apply after initialization but before agents are created
                     agent_app.context.config.logger.progress_display = False
                     agent_app.context.config.logger.show_chat = False
@@ -351,9 +327,7 @@ class FastAgent:
                 active_agents = await self._create_basic_agents(agent_app)
 
                 # Create parallel agents next as they might be dependencies
-                parallel_agents = await self._create_parallel_agents(
-                    agent_app, active_agents
-                )
+                parallel_agents = await self._create_parallel_agents(agent_app, active_agents)
                 active_agents.update(parallel_agents)
 
                 # Create routers next
@@ -361,21 +335,15 @@ class FastAgent:
                 active_agents.update(routers)
 
                 # Create chains next - MOVED UP because evaluator-optimizers might depend on chains
-                chains = await self._create_agents_in_dependency_order(
-                    agent_app, active_agents, AgentType.CHAIN
-                )
+                chains = await self._create_agents_in_dependency_order(agent_app, active_agents, AgentType.CHAIN)
                 active_agents.update(chains)
 
                 # Now create evaluator-optimizers AFTER chains are available
-                evaluator_optimizers = await self._create_evaluator_optimizers(
-                    agent_app, active_agents
-                )
+                evaluator_optimizers = await self._create_evaluator_optimizers(agent_app, active_agents)
                 active_agents.update(evaluator_optimizers)
 
                 # Create orchestrators last as they might depend on any other agent type
-                orchestrators = await self._create_orchestrators(
-                    agent_app, active_agents
-                )
+                orchestrators = await self._create_orchestrators(agent_app, active_agents)
 
                 # Add orchestrators to active_agents (other types were already added)
                 active_agents.update(orchestrators)
@@ -393,9 +361,7 @@ class FastAgent:
 
                     if agent_name not in active_agents:
                         available_agents = ", ".join(active_agents.keys())
-                        print(
-                            f"\n\nError: Agent '{agent_name}' not found. Available agents: {available_agents}"
-                        )
+                        print(f"\n\nError: Agent '{agent_name}' not found. Available agents: {available_agents}")
                         raise SystemExit(1)
 
                     try:
@@ -408,9 +374,7 @@ class FastAgent:
 
                         raise SystemExit(0)
                     except Exception as e:
-                        print(
-                            f"\n\nError sending message to agent '{agent_name}': {str(e)}"
-                        )
+                        print(f"\n\nError sending message to agent '{agent_name}': {str(e)}")
                         raise SystemExit(1)
 
                 yield wrapper
@@ -488,9 +452,7 @@ class FastAgent:
                             print(f"DEBUG {e.message}")
                             pass  # Ignore cleanup errors
 
-    def _handle_error(
-        self, e: Exception, error_type: str, suggestion: str = None
-    ) -> None:
+    def _handle_error(self, e: Exception, error_type: str, suggestion: str = None) -> None:
         """
         Handle errors with consistent formatting and messaging.
 
@@ -535,7 +497,7 @@ class FastAgent:
         port: int = 8000,
         server_name: str = None,
         server_description: str = None,
-    ):
+    ) -> None:
         """
         Run the FastAgent application and expose agents through an MCP server.
 
@@ -555,9 +517,7 @@ class FastAgent:
             )
 
             # Run the MCP server in a separate task
-            server_task = asyncio.create_task(
-                mcp_server.run_async(transport=transport, host=host, port=port)
-            )
+            server_task = asyncio.create_task(mcp_server.run_async(transport=transport, host=host, port=port))
 
             try:
                 # Wait for the server task to complete (or be cancelled)

mcp_agent/core/mcp_content.py

@@ -7,14 +7,14 @@ EmbeddedResource, and other MCP content types with minimal boilerplate.
 
 import base64
 from pathlib import Path
-from typing import Literal, Optional, Union, List, Any
+from typing import Any, List, Literal, Optional, Union
 
 from mcp.types import (
-    TextContent,
-    ImageContent,
+    BlobResourceContents,
     EmbeddedResource,
+    ImageContent,
+    TextContent,
     TextResourceContents,
-    BlobResourceContents,
 )
 
 from mcp_agent.mcp.mime_utils import (
@@ -86,9 +86,7 @@ def MCPImage(
 
     return {
         "role": role,
-        "content": ImageContent(
-            type="image", data=b64_data, mimeType=mime_type, annotations=annotations
-        ),
+        "content": ImageContent(type="image", data=b64_data, mimeType=mime_type, annotations=annotations),
     }
 
 
@@ -134,21 +132,15 @@ def MCPFile(
             # Fallback to binary if text read fails
             binary_data = path.read_bytes()
             b64_data = base64.b64encode(binary_data).decode("ascii")
-            resource = BlobResourceContents(
-                uri=uri, blob=b64_data, mimeType=mime_type or "application/octet-stream"
-            )
+            resource = BlobResourceContents(uri=uri, blob=b64_data, mimeType=mime_type or "application/octet-stream")
 
     return {
         "role": role,
-        "content": EmbeddedResource(
-            type="resource", resource=resource, annotations=annotations
-        ),
+        "content": EmbeddedResource(type="resource", resource=resource, annotations=annotations),
     }
 
 
-def MCPPrompt(
-    *content_items, role: Literal["user", "assistant"] = "user"
-) -> List[dict]:
+def MCPPrompt(*content_items, role: Literal["user", "assistant"] = "user") -> List[dict]:
     """
     Create one or more prompt messages with various content types.
 

mcp_agent/core/prompt.py

@@ -5,10 +5,11 @@ Prompt class for easily creating and working with MCP prompt content.
 from typing import List, Literal
 
 from mcp.types import PromptMessage
+
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 # Import our content helper functions
-from .mcp_content import User, Assistant, MCPPrompt
+from .mcp_content import Assistant, MCPPrompt, User
 
 
 class Prompt:
@@ -39,9 +40,7 @@ class Prompt:
             A PromptMessageMultipart with user role and the specified content
         """
         messages = User(*content_items)
-        return PromptMessageMultipart(
-            role="user", content=[msg["content"] for msg in messages]
-        )
+        return PromptMessageMultipart(role="user", content=[msg["content"] for msg in messages])
 
     @classmethod
     def assistant(cls, *content_items) -> PromptMessageMultipart:
@@ -55,14 +54,10 @@ class Prompt:
             A PromptMessageMultipart with assistant role and the specified content
         """
         messages = Assistant(*content_items)
-        return PromptMessageMultipart(
-            role="assistant", content=[msg["content"] for msg in messages]
-        )
+        return PromptMessageMultipart(role="assistant", content=[msg["content"] for msg in messages])
 
     @classmethod
-    def message(
-        cls, *content_items, role: Literal["user", "assistant"] = "user"
-    ) -> PromptMessageMultipart:
+    def message(cls, *content_items, role: Literal["user", "assistant"] = "user") -> PromptMessageMultipart:
         """
         Create a PromptMessageMultipart with the specified role and content items.
 
@@ -100,7 +95,7 @@ class Prompt:
         for item in messages:
             if isinstance(item, PromptMessageMultipart):
                 # Convert PromptMessageMultipart to a list of PromptMessages
-                result.extend(item.to_prompt_messages())
+                result.extend(item.from_multipart())
             elif isinstance(item, dict) and "role" in item and "content" in item:
                 # Convert a single message dict to PromptMessage
                 result.append(PromptMessage(**item))
@@ -114,9 +109,7 @@ class Prompt:
         return result
 
     @classmethod
-    def from_multipart(
-        cls, multipart: List[PromptMessageMultipart]
-    ) -> List[PromptMessage]:
+    def from_multipart(cls, multipart: List[PromptMessageMultipart]) -> List[PromptMessage]:
         """
         Convert a list of PromptMessageMultipart objects to PromptMessages.
 
@@ -128,5 +121,5 @@ class Prompt:
         """
         result = []
         for mp in multipart:
-            result.extend(mp.to_prompt_messages())
+            result.extend(mp.from_multipart())
         return result