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

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -1,5 +1,5 @@
 import os
-from typing import List, Type, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Type
 
 from mcp_agent.workflows.llm.providers.multipart_converter_anthropic import (
     AnthropicConverter,
@@ -9,6 +9,8 @@ from mcp_agent.workflows.llm.providers.sampling_converter_anthropic import (
 )
 
 if TYPE_CHECKING:
+    from mcp import ListToolsResult
+
     from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 
@@ -20,22 +22,22 @@ from anthropic.types import (
     TextBlockParam,
     ToolParam,
     ToolUseBlockParam,
+    Usage,
 )
 from mcp.types import (
-    CallToolRequestParams,
     CallToolRequest,
+    CallToolRequestParams,
 )
 from pydantic_core import from_json
+from rich.text import Text
 
+from mcp_agent.core.exceptions import ProviderKeyError
+from mcp_agent.logging.logger import get_logger
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     ModelT,
     RequestParams,
 )
-from mcp_agent.core.exceptions import ProviderKeyError
-from rich.text import Text
-
-from mcp_agent.logging.logger import get_logger
 
 DEFAULT_ANTHROPIC_MODEL = "claude-3-7-sonnet-latest"
 
@@ -48,7 +50,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
     selecting appropriate tools, and determining what information to retain.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         self.provider = "Anthropic"
         # Initialize logger - keep it simple without name reference
         self.logger = get_logger(__name__)
@@ -60,7 +62,6 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         """Initialize Anthropic-specific default parameters"""
         return RequestParams(
             model=kwargs.get("model", DEFAULT_ANTHROPIC_MODEL),
-            modelPreferences=self.model_preferences,
             maxTokens=4096,  # default haiku3
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
@@ -86,8 +87,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         except AuthenticationError as e:
             raise ProviderKeyError(
                 "Invalid Anthropic API key",
-                "The configured Anthropic API key was rejected.\n"
-                "Please check that your API key is valid and not expired.",
+                "The configured Anthropic API key was rejected.\nPlease check that your API key is valid and not expired.",
             ) from e
 
         # Always include prompt messages, but only include conversation history
@@ -101,14 +101,14 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         else:
             messages.append(message)
 
-        response = await self.aggregator.list_tools()
+        tool_list: ListToolsResult = await self.aggregator.list_tools()
         available_tools: List[ToolParam] = [
-            {
-                "name": tool.name,
-                "description": tool.description,
-                "input_schema": tool.inputSchema,
-            }
-            for tool in response.tools
+            ToolParam(
+                name=tool.name,
+                description=tool.description or "",
+                input_schema=tool.inputSchema,
+            )
+            for tool in tool_list.tools
         ]
 
         responses: List[Message] = []
@@ -135,17 +135,14 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
             self.logger.debug(f"{arguments}")
 
-            executor_result = await self.executor.execute(
-                anthropic.messages.create, **arguments
-            )
+            executor_result = await self.executor.execute(anthropic.messages.create, **arguments)
 
             response = executor_result[0]
 
             if isinstance(response, AuthenticationError):
                 raise ProviderKeyError(
                     "Invalid Anthropic API key",
-                    "The configured Anthropic API key was rejected.\n"
-                    "Please check that your API key is valid and not expired.",
+                    "The configured Anthropic API key was rejected.\nPlease check that your API key is valid and not expired.",
                 ) from response
             elif isinstance(response, BaseException):
                 error_details = str(response)
@@ -155,13 +152,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 if hasattr(response, "status_code") and hasattr(response, "response"):
                     try:
                         error_json = response.response.json()
-                        error_details = (
-                            f"Error code: {response.status_code} - {error_json}"
-                        )
+                        error_details = f"Error code: {response.status_code} - {error_json}"
                     except:  # noqa: E722
-                        error_details = (
-                            f"Error code: {response.status_code} - {str(response)}"
-                        )
+                        error_details = f"Error code: {response.status_code} - {str(response)}"
 
                 # Convert other errors to text response
                 error_message = f"Error during generation: {error_details}"
@@ -172,7 +165,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                     type="message",
                     content=[TextBlock(type="text", text=error_message)],
                     stop_reason="end_turn",  # Must be one of the allowed values
-                    usage={"input_tokens": 0, "output_tokens": 0},  # Required field
+                    usage=Usage(input_tokens=0, output_tokens=0),  # Required field
                 )
 
             self.logger.debug(
@@ -194,22 +187,16 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
                 await self.show_assistant_message(message_text)
 
-                self.logger.debug(
-                    f"Iteration {i}: Stopping because finish_reason is 'end_turn'"
-                )
+                self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'end_turn'")
                 break
             elif response.stop_reason == "stop_sequence":
                 # We have reached a stop sequence
-                self.logger.debug(
-                    f"Iteration {i}: Stopping because finish_reason is 'stop_sequence'"
-                )
+                self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'stop_sequence'")
                 break
             elif response.stop_reason == "max_tokens":
                 # We have reached the max tokens limit
 
-                self.logger.debug(
-                    f"Iteration {i}: Stopping because finish_reason is 'max_tokens'"
-                )
+                self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'max_tokens'")
                 if params.maxTokens is not None:
                     message_text = Text(
                         f"the assistant has reached the maximum token limit ({params.maxTokens})",
@@ -256,22 +243,16 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                         self.show_tool_call(available_tools, tool_name, tool_args)
                         tool_call_request = CallToolRequest(
                             method="tools/call",
-                            params=CallToolRequestParams(
-                                name=tool_name, arguments=tool_args
-                            ),
+                            params=CallToolRequestParams(name=tool_name, arguments=tool_args),
                         )
                         # TODO -- support MCP isError etc.
-                        result = await self.call_tool(
-                            request=tool_call_request, tool_call_id=tool_use_id
-                        )
+                        result = await self.call_tool(request=tool_call_request, tool_call_id=tool_use_id)
                         self.show_tool_result(result)
 
                         # Add each result to our collection
                         tool_results.append((tool_use_id, result))
 
-                    messages.append(
-                        AnthropicConverter.create_tool_results_message(tool_results)
-                    )
+                    messages.append(AnthropicConverter.create_tool_results_message(tool_results))
 
         # Only save the new conversation messages to history if use_history is true
         # Keep the prompt messages separate
@@ -352,15 +333,13 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         # Join all collected text
         return "\n".join(final_text)
 
-    async def generate_prompt(
-        self, prompt: "PromptMessageMultipart", request_params: RequestParams | None
-    ) -> str:
-        return await self.generate_str(
-            AnthropicConverter.convert_to_anthropic(prompt), request_params
-        )
+    async def generate_prompt(self, prompt: "PromptMessageMultipart", request_params: RequestParams | None) -> str:
+        return await self.generate_str(AnthropicConverter.convert_to_anthropic(prompt), request_params)
 
     async def _apply_prompt_template_provider_specific(
-        self, multipart_messages: List["PromptMessageMultipart"]
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: RequestParams | None = None,
     ) -> str:
         """
         Anthropic-specific implementation of apply_prompt_template that handles
@@ -377,11 +356,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         last_message = multipart_messages[-1]
 
         # Add all previous messages to history (or all messages if last is from assistant)
-        messages_to_add = (
-            multipart_messages[:-1]
-            if last_message.role == "user"
-            else multipart_messages
-        )
+        messages_to_add = multipart_messages[:-1] if last_message.role == "user" else multipart_messages
         converted = []
         for msg in messages_to_add:
             converted.append(AnthropicConverter.convert_to_anthropic(msg))
@@ -389,16 +364,12 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         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"
-            )
+            self.logger.debug("Last message in prompt is from user, generating assistant response")
             message_param = AnthropicConverter.convert_to_anthropic(last_message)
-            return await self.generate_str(message_param)
+            return await self.generate_str(message_param, request_params)
         else:
             # For assistant messages: Return the last message content as text
-            self.logger.debug(
-                "Last message in prompt is from assistant, returning it directly"
-            )
+            self.logger.debug("Last message in prompt is from assistant, returning it directly")
             return str(last_message)
 
     async def _save_history_to_file(self, command: str) -> str:
@@ -423,19 +394,17 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             messages = self.history.get(include_history=True)
 
             # Import required utilities
-            from mcp_agent.workflows.llm.anthropic_utils import (
-                anthropic_message_param_to_prompt_message_multipart,
-            )
             from mcp_agent.mcp.prompt_serialization import (
                 multipart_messages_to_delimited_format,
             )
+            from mcp_agent.workflows.llm.anthropic_utils import (
+                anthropic_message_param_to_prompt_message_multipart,
+            )
 
             # Convert message params to PromptMessageMultipart objects
             multipart_messages = []
             for msg in messages:
-                multipart_messages.append(
-                    anthropic_message_param_to_prompt_message_multipart(msg)
-                )
+                multipart_messages.append(anthropic_message_param_to_prompt_message_multipart(msg))
 
             # Convert to delimited format
             delimited_content = multipart_messages_to_delimited_format(
@@ -457,7 +426,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
     async def generate_structured(
         self,
-        message,
+        message: str,
         response_model: Type[ModelT],
         request_params: RequestParams | None = None,
     ) -> ModelT:
@@ -474,9 +443,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         return response_model.model_validate(from_json(response, allow_partial=True))
 
     @classmethod
-    def convert_message_to_message_param(
-        cls, message: Message, **kwargs
-    ) -> MessageParam:
+    def convert_message_to_message_param(cls, message: Message, **kwargs) -> MessageParam:
         """Convert a response object to an input parameter object to allow LLM calls to be chained."""
         content = []
 

mcp_agent/workflows/llm/augmented_llm_openai.py

@@ -1,5 +1,5 @@
 import os
-from typing import List, Type, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Type
 
 from pydantic_core import from_json
 
@@ -10,30 +10,30 @@ from mcp_agent.workflows.llm.providers.sampling_converter_openai import (
 
 if TYPE_CHECKING:
     from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from openai import OpenAI, AuthenticationError
+from mcp.types import (
+    CallToolRequest,
+    CallToolRequestParams,
+    CallToolResult,
+)
+from openai import AuthenticationError, OpenAI
 
 # from openai.types.beta.chat import
 from openai.types.chat import (
-    ChatCompletionMessageParam,
     ChatCompletionMessage,
+    ChatCompletionMessageParam,
     ChatCompletionSystemMessageParam,
     ChatCompletionToolParam,
     ChatCompletionUserMessageParam,
 )
-from mcp.types import (
-    CallToolRequestParams,
-    CallToolRequest,
-    CallToolResult,
-)
+from rich.text import Text
 
+from mcp_agent.core.exceptions import ProviderKeyError
+from mcp_agent.logging.logger import get_logger
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     ModelT,
     RequestParams,
 )
-from mcp_agent.core.exceptions import ProviderKeyError
-from mcp_agent.logging.logger import get_logger
-from rich.text import Text
 
 _logger = get_logger(__name__)
 
@@ -41,16 +41,14 @@ DEFAULT_OPENAI_MODEL = "gpt-4o"
 DEFAULT_REASONING_EFFORT = "medium"
 
 
-class OpenAIAugmentedLLM(
-    AugmentedLLM[ChatCompletionMessageParam, ChatCompletionMessage]
-):
+class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletionMessage]):
     """
     The basic building block of agentic systems is an LLM enhanced with augmentations
     such as retrieval, tools, and memory provided from a collection of MCP servers.
     This implementation uses OpenAI's ChatCompletion as the LLM.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         # Set type_converter before calling super().__init__
         if "type_converter" not in kwargs:
             kwargs["type_converter"] = OpenAISamplingConverter
@@ -64,22 +62,14 @@ class OpenAIAugmentedLLM(
         # Set up reasoning-related attributes
         self._reasoning_effort = kwargs.get("reasoning_effort", None)
         if self.context and self.context.config and self.context.config.openai:
-            if self._reasoning_effort is None and hasattr(
-                self.context.config.openai, "reasoning_effort"
-            ):
+            if self._reasoning_effort is None and hasattr(self.context.config.openai, "reasoning_effort"):
                 self._reasoning_effort = self.context.config.openai.reasoning_effort
 
         # Determine if we're using a reasoning model
-        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")
-        )
+        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"))
         if self._reasoning:
-            self.logger.info(
-                f"Using reasoning model '{chosen_model}' with '{self._reasoning_effort}' reasoning effort"
-            )
+            self.logger.info(f"Using reasoning model '{chosen_model}' with '{self._reasoning_effort}' reasoning effort")
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize OpenAI-specific default parameters"""
@@ -92,7 +82,6 @@ class OpenAIAugmentedLLM(
 
         return RequestParams(
             model=chosen_model,
-            modelPreferences=self.model_preferences,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
             max_iterations=10,
@@ -121,9 +110,7 @@ class OpenAIAugmentedLLM(
         return api_key
 
     def _base_url(self) -> str:
-        return (
-            self.context.config.openai.base_url if self.context.config.openai else None
-        )
+        return self.context.config.openai.base_url if self.context.config.openai else None
 
     async def generate(
         self,
@@ -144,24 +131,19 @@ class OpenAIAugmentedLLM(
         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.",
+                "The configured OpenAI API key was rejected.\n" "Please check that your API key is valid and not expired.",
             ) from e
 
         system_prompt = self.instruction or params.systemPrompt
         if system_prompt:
-            messages.append(
-                ChatCompletionSystemMessageParam(role="system", content=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)
-            )
+            messages.append(ChatCompletionUserMessageParam(role="user", content=message))
         elif isinstance(message, list):
             messages.extend(message)
         else:
@@ -187,9 +169,7 @@ class OpenAIAugmentedLLM(
         model = await self.select_model(params)
         chat_turn = len(messages) // 2
         if self._reasoning:
-            self.show_user_message(
-                str(message), f"{model} ({self._reasoning_effort})", chat_turn
-            )
+            self.show_user_message(str(message), f"{model} ({self._reasoning_effort})", chat_turn)
         else:
             self.show_user_message(str(message), model, chat_turn)
 
@@ -218,9 +198,7 @@ class OpenAIAugmentedLLM(
             self._log_chat_progress(chat_turn, model=model)
 
             if response_model is None:
-                executor_result = await self.executor.execute(
-                    openai_client.chat.completions.create, **arguments
-                )
+                executor_result = await self.executor.execute(openai_client.chat.completions.create, **arguments)
             else:
                 executor_result = await self.executor.execute(
                     openai_client.beta.chat.completions.parse,
@@ -238,8 +216,7 @@ class OpenAIAugmentedLLM(
             if isinstance(response, AuthenticationError):
                 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.",
+                    "The configured OpenAI API key was rejected.\n" "Please check that your API key is valid and not expired.",
                 ) from response
             elif isinstance(response, BaseException):
                 self.logger.error(f"Error: {response}")
@@ -255,21 +232,14 @@ class OpenAIAugmentedLLM(
             message = choice.message
             responses.append(message)
 
-            converted_message = self.convert_message_to_message_param(
-                message, name=self.name
-            )
+            converted_message = self.convert_message_to_message_param(message, name=self.name)
             messages.append(converted_message)
             message_text = converted_message.content
-            if (
-                choice.finish_reason in ["tool_calls", "function_call"]
-                and message.tool_calls
-            ):
+            if choice.finish_reason in ["tool_calls", "function_call"] and message.tool_calls:
                 if message_text:
                     await self.show_assistant_message(
                         message_text,
-                        message.tool_calls[
-                            0
-                        ].function.name,  # TODO support displaying multiple tool calls
+                        message.tool_calls[0].function.name,  # TODO support displaying multiple tool calls
                     )
                 else:
                     await self.show_assistant_message(
@@ -291,9 +261,7 @@ class OpenAIAugmentedLLM(
                         method="tools/call",
                         params=CallToolRequestParams(
                             name=tool_call.function.name,
-                            arguments=from_json(
-                                tool_call.function.arguments, allow_partial=True
-                            ),
+                            arguments=from_json(tool_call.function.arguments, allow_partial=True),
                         ),
                     )
                     result = await self.call_tool(tool_call_request, tool_call.id)
@@ -301,18 +269,12 @@ class OpenAIAugmentedLLM(
 
                     tool_results.append((tool_call.id, result))
 
-                messages.extend(
-                    OpenAIConverter.convert_function_results_to_openai(tool_results)
-                )
+                messages.extend(OpenAIConverter.convert_function_results_to_openai(tool_results))
 
-                self.logger.debug(
-                    f"Iteration {i}: Tool call results: {str(tool_results) if tool_results else 'None'}"
-                )
+                self.logger.debug(f"Iteration {i}: Tool call results: {str(tool_results) if tool_results else 'None'}")
             elif choice.finish_reason == "length":
                 # We have reached the max tokens limit
-                self.logger.debug(
-                    f"Iteration {i}: Stopping because finish_reason is 'length'"
-                )
+                self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'length'")
                 if request_params and request_params.maxTokens is not None:
                     message_text = Text(
                         f"the assistant has reached the maximum token limit ({request_params.maxTokens})",
@@ -329,15 +291,11 @@ class OpenAIAugmentedLLM(
                 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'"
-                )
+                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'"
-                )
+                self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'stop'")
                 if message_text:
                     await self.show_assistant_message(message_text, "")
                 break
@@ -395,7 +353,9 @@ class OpenAIAugmentedLLM(
         return "\n".join(final_text)
 
     async def _apply_prompt_template_provider_specific(
-        self, multipart_messages: List["PromptMessageMultipart"]
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: RequestParams | None = None,
     ) -> str:
         """
         OpenAI-specific implementation of apply_prompt_template that handles
@@ -415,11 +375,7 @@ class OpenAIAugmentedLLM(
         last_message = multipart_messages[-1]
 
         # Add all previous messages to history (or all messages if last is from assistant)
-        messages_to_add = (
-            multipart_messages[:-1]
-            if last_message.role == "user"
-            else multipart_messages
-        )
+        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))
@@ -427,16 +383,12 @@ class OpenAIAugmentedLLM(
 
         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"
-            )
+            self.logger.debug("Last message in prompt is from user, generating assistant response")
             message_param = OpenAIConverter.convert_to_openai(last_message)
-            return await self.generate_str(message_param)
+            return await self.generate_str(message_param, request_params)
         else:
             # For assistant messages: Return the last message content as text
-            self.logger.debug(
-                "Last message in prompt is from assistant, returning it directly"
-            )
+            self.logger.debug("Last message in prompt is from assistant, returning it directly")
             return str(last_message)
 
     async def _save_history_to_file(self, command: str) -> str:
@@ -461,12 +413,12 @@ class OpenAIAugmentedLLM(
             messages = self.history.get(include_history=True)
 
             # Import required utilities
-            from mcp_agent.workflows.llm.openai_utils import (
-                openai_message_param_to_prompt_message_multipart,
-            )
             from mcp_agent.mcp.prompt_serialization import (
                 multipart_messages_to_delimited_format,
             )
+            from mcp_agent.workflows.llm.openai_utils import (
+                openai_message_param_to_prompt_message_multipart,
+            )
 
             # Convert message params to PromptMessageMultipart objects
             multipart_messages = []
@@ -476,9 +428,7 @@ class OpenAIAugmentedLLM(
                     continue
 
                 # Convert the message to a multipart message
-                multipart_messages.append(
-                    openai_message_param_to_prompt_message_multipart(msg)
-                )
+                multipart_messages.append(openai_message_param_to_prompt_message_multipart(msg))
 
             # Convert to delimited format
             delimited_content = multipart_messages_to_delimited_format(
@@ -511,18 +461,14 @@ class OpenAIAugmentedLLM(
         )
         return responses[0].parsed
 
-    async def generate_prompt(
-        self, prompt: "PromptMessageMultipart", request_params: RequestParams | None
-    ) -> str:
+    async def generate_prompt(self, prompt: "PromptMessageMultipart", request_params: RequestParams | None) -> str:
         converted_prompt = OpenAIConverter.convert_to_openai(prompt)
         return await self.generate_str(converted_prompt, request_params)
 
     async def pre_tool_call(self, tool_call_id: str | None, request: CallToolRequest):
         return request
 
-    async def post_tool_call(
-        self, tool_call_id: str | None, request: CallToolRequest, result: CallToolResult
-    ):
+    async def post_tool_call(self, tool_call_id: str | None, request: CallToolRequest, result: CallToolResult):
         return result
 
     def message_param_str(self, message: ChatCompletionMessageParam) -> str: