fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.1__py3-none-any.whl

mcp_agent/llm/providers/augmented_llm_deepseek.py → fast_agent/llm/provider/openai/llm_deepseek.py

@@ -6,17 +6,16 @@ from openai.types.chat import (
     ChatCompletionMessage,
 )
 
-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 mcp_agent.mcp.interfaces import ModelT
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.interfaces import ModelT
+from fast_agent.llm.provider.openai.llm_openai import OpenAILLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.types import PromptMessageExtended, RequestParams
 
 DEEPSEEK_BASE_URL = "https://api.deepseek.com"
 DEFAULT_DEEPSEEK_MODEL = "deepseekchat"  # current Deepseek only has two type models
 
 
-class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
+class DeepSeekLLM(OpenAILLM):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, provider=Provider.DEEPSEEK, **kwargs)
 
@@ -24,11 +23,11 @@ class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
         """Initialize Deepseek-specific default parameters"""
         # Get base defaults from parent (includes ModelDatabase lookup)
         base_params = super()._initialize_default_params(kwargs)
-        
+
         # Override with Deepseek-specific settings
         chosen_model = kwargs.get("model", DEFAULT_DEEPSEEK_MODEL)
         base_params.model = chosen_model
-        
+
         return base_params
 
     def _base_url(self) -> str:
@@ -40,10 +39,10 @@ class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
 
     async def _apply_prompt_provider_specific_structured(
         self,
-        multipart_messages: List[PromptMessageMultipart],
+        multipart_messages: List[PromptMessageExtended],
         model: Type[ModelT],
         request_params: RequestParams | None = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:  # noqa: F821
+    ) -> Tuple[ModelT | None, PromptMessageExtended]:  # noqa: F821
         request_params = self.get_request_params(request_params)
 
         request_params.response_format = {"type": "json_object"}
@@ -78,7 +77,7 @@ class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
             - All required fields must be included"""
         )
 
-        result: PromptMessageMultipart = await self._apply_prompt_provider_specific(
+        result: PromptMessageExtended = await self._apply_prompt_provider_specific(
             multipart_messages, request_params
         )
         return self._structured_from_multipart(result, model)

mcp_agent/llm/providers/augmented_llm_generic.py → fast_agent/llm/provider/openai/llm_generic.py

@@ -1,15 +1,15 @@
 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
 
 DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434/v1"
 DEFAULT_OLLAMA_MODEL = "llama3.2:latest"
 DEFAULT_OLLAMA_API_KEY = "ollama"
 
 
-class GenericAugmentedLLM(OpenAIAugmentedLLM):
+class GenericLLM(OpenAILLM):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(
             *args, provider=Provider.GENERIC, **kwargs

mcp_agent/llm/providers/augmented_llm_google_oai.py → fast_agent/llm/provider/openai/llm_google_oai.py

@@ -1,12 +1,12 @@
-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
 
 GOOGLE_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai"
 DEFAULT_GOOGLE_MODEL = "gemini-2.0-flash"
 
 
-class GoogleOaiAugmentedLLM(OpenAIAugmentedLLM):
+class GoogleOaiLLM(OpenAILLM):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, provider=Provider.GOOGLE_OAI, **kwargs)
 

mcp_agent/llm/providers/augmented_llm_groq.py → fast_agent/llm/provider/openai/llm_groq.py

@@ -2,14 +2,13 @@ from typing import List, Tuple, Type, cast
 
 from pydantic_core import from_json
 
-from mcp_agent.core.request_params import RequestParams
-from mcp_agent.llm.model_database import ModelDatabase
-from mcp_agent.llm.provider_types import Provider
-from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.helpers.content_helpers import get_text, split_thinking_content
-from mcp_agent.mcp.interfaces import ModelT
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.interfaces import ModelT
+from fast_agent.llm.model_database import ModelDatabase
+from fast_agent.llm.provider.openai.llm_openai import OpenAILLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.mcp.helpers.content_helpers import get_text, split_thinking_content
+from fast_agent.types import PromptMessageExtended, RequestParams
 
 GROQ_BASE_URL = "https://api.groq.com/openai/v1"
 DEFAULT_GROQ_MODEL = "moonshotai/kimi-k2-instruct"
@@ -19,7 +18,7 @@ DEFAULT_GROQ_MODEL = "moonshotai/kimi-k2-instruct"
 ### - deduplicating between this and the deepseek llm
 
 
-class GroqAugmentedLLM(OpenAIAugmentedLLM):
+class GroqLLM(OpenAILLM):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, provider=Provider.GROQ, **kwargs)
 
@@ -37,10 +36,10 @@ class GroqAugmentedLLM(OpenAIAugmentedLLM):
 
     async def _apply_prompt_provider_specific_structured(
         self,
-        multipart_messages: List[PromptMessageMultipart],
+        multipart_messages: List[PromptMessageExtended],
         model: Type[ModelT],
         request_params: RequestParams | None = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:  # noqa: F821
+    ) -> Tuple[ModelT | None, PromptMessageExtended]:  # noqa: F821
         request_params = self.get_request_params(request_params)
 
         assert self.default_request_params
@@ -51,9 +50,7 @@ class GroqAugmentedLLM(OpenAIAugmentedLLM):
 
             # Create a cleaner format description from full schema
             full_schema = model.model_json_schema()
-            format_description = self._schema_to_json_object(
-                full_schema, full_schema.get("$defs")
-            )
+            format_description = self._schema_to_json_object(full_schema, full_schema.get("$defs"))
 
             multipart_messages[-1].add_text(
                 f"""YOU MUST RESPOND WITH A JSON OBJECT IN EXACTLY THIS FORMAT:
@@ -64,9 +61,10 @@ IMPORTANT RULES:
 - Do NOT include "properties" or "schema" wrappers
 - Do NOT use code fences or markdown
 - The response must be valid JSON that matches the format above
-- All required fields must be included""")
+- All required fields must be included"""
+            )
 
-        result: PromptMessageMultipart = await self._apply_prompt_provider_specific(
+        result: PromptMessageExtended = await self._apply_prompt_provider_specific(
             multipart_messages, request_params
         )
         reasoning_mode: str | None = ModelDatabase.get_reasoning(llm_model)

mcp_agent/llm/providers/augmented_llm_openai.py → fast_agent/llm/provider/openai/llm_openai.py

@@ -1,9 +1,9 @@
-from typing import Dict, List
+from typing import Any, Dict, List
 
+from mcp import Tool
 from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
-    CallToolResult,
     ContentBlock,
     TextContent,
 )
@@ -18,23 +18,20 @@ from openai.types.chat import (
     ChatCompletionToolParam,
 )
 from pydantic_core import from_json
-from rich.text import Text
 
-from mcp_agent.core.exceptions import ProviderKeyError
-from mcp_agent.core.prompt import Prompt
-from mcp_agent.event_progress import ProgressAction
-from mcp_agent.llm.augmented_llm import (
-    AugmentedLLM,
+from fast_agent.core.exceptions import ProviderKeyError
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.core.prompt import Prompt
+from fast_agent.event_progress import ProgressAction
+from fast_agent.llm.fastagent_llm import (
+    FastAgentLLM,
     RequestParams,
 )
-from mcp_agent.llm.provider_types import Provider
-from mcp_agent.llm.providers.multipart_converter_openai import OpenAIConverter, OpenAIMessage
-from mcp_agent.llm.providers.sampling_converter_openai import (
-    OpenAISamplingConverter,
-)
-from mcp_agent.llm.usage_tracking import TurnUsage
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.llm.provider.openai.multipart_converter_openai import OpenAIConverter, OpenAIMessage
+from fast_agent.llm.provider_types import Provider
+from fast_agent.llm.usage_tracking import TurnUsage
+from fast_agent.types import PromptMessageExtended
+from fast_agent.types.llm_stop_reason import LlmStopReason
 
 _logger = get_logger(__name__)
 
@@ -42,31 +39,22 @@ DEFAULT_OPENAI_MODEL = "gpt-4.1-mini"
 DEFAULT_REASONING_EFFORT = "medium"
 
 
-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.
-    """
-
+class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage]):
     # 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,
-        AugmentedLLM.PARAM_TEMPLATE_VARS,
-        AugmentedLLM.PARAM_MCP_METADATA,
+        FastAgentLLM.PARAM_MESSAGES,
+        FastAgentLLM.PARAM_MODEL,
+        FastAgentLLM.PARAM_MAX_TOKENS,
+        FastAgentLLM.PARAM_SYSTEM_PROMPT,
+        FastAgentLLM.PARAM_PARALLEL_TOOL_CALLS,
+        FastAgentLLM.PARAM_USE_HISTORY,
+        FastAgentLLM.PARAM_MAX_ITERATIONS,
+        FastAgentLLM.PARAM_TEMPLATE_VARS,
+        FastAgentLLM.PARAM_MCP_METADATA,
+        FastAgentLLM.PARAM_STOP_SEQUENCES,
     }
 
     def __init__(self, provider: Provider = Provider.OPENAI, *args, **kwargs) -> None:
-        # Set type_converter before calling super().__init__
-        if "type_converter" not in kwargs:
-            kwargs["type_converter"] = OpenAISamplingConverter
-
         super().__init__(*args, provider=provider, **kwargs)
 
         # Initialize logger with name if available
@@ -144,8 +132,14 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                 # Use base class method for token estimation and progress emission
                 estimated_tokens = self._update_streaming_progress(content, model, estimated_tokens)
 
-        # Get the final completion with usage data
-        final_completion = state.get_final_completion()
+        # Check if we hit the length limit to avoid LengthFinishReasonError
+        current_snapshot = state.current_completion_snapshot
+        if current_snapshot.choices and current_snapshot.choices[0].finish_reason == "length":
+            # Return the current snapshot directly to avoid exception
+            final_completion = current_snapshot
+        else:
+            # Get the final completion with usage data (may include structured output parsing)
+            final_completion = state.get_final_completion()
 
         # Log final usage information
         if hasattr(final_completion, "usage") and final_completion.usage:
@@ -296,9 +290,10 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
     async def _openai_completion(
         self,
-        message: OpenAIMessage,
+        message: List[OpenAIMessage] | None,
         request_params: RequestParams | None = None,
-    ) -> List[ContentBlock]:
+        tools: List[Tool] | None = None,
+    ) -> PromptMessageExtended:
         """
         Process a query using an LLM and available tools.
         The default implementation uses OpenAI's ChatCompletion as the LLM.
@@ -307,7 +302,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
         request_params = self.get_request_params(request_params=request_params)
 
-        responses: List[ContentBlock] = []
+        response_content_blocks: List[ContentBlock] = []
         model_name = self.default_request_params.model or DEFAULT_OPENAI_MODEL
 
         # TODO -- move this in to agent context management / agent group handling
@@ -317,9 +312,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             messages.append(ChatCompletionSystemMessageParam(role="system", content=system_prompt))
 
         messages.extend(self.history.get(include_completion_history=request_params.use_history))
-        messages.append(message)
+        if message is not None:
+            messages.extend(message)
 
-        response = await self.aggregator.list_tools()
         available_tools: List[ChatCompletionToolParam] | None = [
             {
                 "type": "function",
@@ -329,7 +324,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                     "parameters": self.adjust_schema(tool.inputSchema),
                 },
             }
-            for tool in response.tools
+            for tool in tools or []
         ]
 
         if not available_tools:
@@ -339,154 +334,91 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                 available_tools = []
 
         # 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._log_chat_progress(self.chat_turn(), model=self.default_request_params.model)
-
-            # Use basic streaming API
-            stream = await self._openai_client().chat.completions.create(**arguments)
-            # Process the stream
-            response = await self._process_stream(stream, self.default_request_params.model)
-            # Track usage if response is valid and has usage data
-            if (
-                hasattr(response, "usage")
-                and response.usage
-                and not isinstance(response, BaseException)
-            ):
-                try:
-                    model_name = self.default_request_params.model or DEFAULT_OPENAI_MODEL
-                    turn_usage = TurnUsage.from_openai(response.usage, model_name)
-                    self._finalize_turn_usage(turn_usage)
-                except Exception as e:
-                    self.logger.warning(f"Failed to track usage: {e}")
-
-            self.logger.debug(
-                "OpenAI completion response:",
-                data=response,
-            )
-
-            if isinstance(response, AuthenticationError):
-                raise ProviderKeyError(
-                    "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
-            elif isinstance(response, BaseException):
-                self.logger.error(f"Error: {response}")
-                break
-
-            if not response.choices or len(response.choices) == 0:
-                # No response from the model, we're done
-                break
-
-            choice = response.choices[0]
-            message = choice.message
-            # prep for image/audio gen models
-            if message.content:
-                responses.append(TextContent(type="text", text=message.content))
-
-            # ParsedChatCompletionMessage is compatible with ChatCompletionMessage
-            # since it inherits from it, so we can use it directly
-            # Convert to dict and remove None values
-            message_dict = message.model_dump()
-            message_dict = {k: v for k, v in message_dict.items() if v is not None}
-            if model_name in (
-                "deepseek-r1-distill-llama-70b",
-                "openai/gpt-oss-120b",
-                "openai/gpt-oss-20b",
-            ):
-                message_dict.pop("reasoning", None)
-                message_dict.pop("channel", None)
-
-            messages.append(message_dict)
-
-            message_text = message.content
-            if await self._is_tool_stop_reason(choice.finish_reason) 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
-                    )
-                else:
-                    await self.show_assistant_message(
-                        Text(
-                            "the assistant requested tool calls",
-                            style="dim green italic",
-                        ),
-                        message.tool_calls[0].function.name,
-                    )
+        arguments: dict[str, Any] = self._prepare_api_request(
+            messages, available_tools, request_params
+        )
+        if not self._reasoning and request_params.stopSequences:
+            arguments["stop"] = request_params.stopSequences
 
-                tool_results = []
+        self.logger.debug(f"OpenAI completion requested for: {arguments}")
 
-                for tool_call in message.tool_calls:
-                    self.show_tool_call(
-                        available_tools,
-                        tool_call.function.name,
-                        tool_call.function.arguments,
-                    )
-                    tool_call_request = CallToolRequest(
-                        method="tools/call",
-                        params=CallToolRequestParams(
-                            name=tool_call.function.name,
-                            arguments={}
-                            if not tool_call.function.arguments
-                            or tool_call.function.arguments.strip() == ""
-                            else from_json(tool_call.function.arguments, allow_partial=True),
-                        ),
-                    )
-
-                    try:
-                        result = await self.call_tool(tool_call_request, tool_call.id)
-                        self.show_tool_result(result)
-                        tool_results.append((tool_call.id, result))
-                        responses.extend(result.content)
-                    except Exception as e:
-                        self.logger.error(f"Tool call {tool_call.id} failed with error: {e}")
-                        # Still add the tool_call_id with an error result to prevent missing responses
-                        error_result = CallToolResult(
-                            content=[TextContent(type="text", text=f"Tool call failed: {str(e)}")]
-                        )
-                        tool_results.append((tool_call.id, error_result))
-
-                converted_messages = OpenAIConverter.convert_function_results_to_openai(
-                    tool_results
-                )
-                messages.extend(converted_messages)
+        self._log_chat_progress(self.chat_turn(), model=self.default_request_params.model)
+        model_name = self.default_request_params.model or DEFAULT_OPENAI_MODEL
 
-                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'")
-                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})",
-                        style="dim green italic",
-                    )
-                else:
-                    message_text = Text(
-                        "the assistant has reached the maximum token limit",
-                        style="dim green italic",
-                    )
+        # Use basic streaming API
+        stream = await self._openai_client().chat.completions.create(**arguments)
+        # Process the stream
+        response = await self._process_stream(stream, model_name)
+        # Track usage if response is valid and has usage data
+        if (
+            hasattr(response, "usage")
+            and response.usage
+            and not isinstance(response, BaseException)
+        ):
+            try:
+                turn_usage = TurnUsage.from_openai(response.usage, model_name)
+                self._finalize_turn_usage(turn_usage)
+            except Exception as e:
+                self.logger.warning(f"Failed to track usage: {e}")
+
+        self.logger.debug(
+            "OpenAI completion response:",
+            data=response,
+        )
 
-                await self.show_assistant_message(message_text)
-                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'"
+        if isinstance(response, AuthenticationError):
+            raise ProviderKeyError(
+                "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
+        elif isinstance(response, BaseException):
+            self.logger.error(f"Error: {response}")
+
+        choice = response.choices[0]
+        message = choice.message
+        # prep for image/audio gen models
+        if message.content:
+            response_content_blocks.append(TextContent(type="text", text=message.content))
+
+        # ParsedChatCompletionMessage is compatible with ChatCompletionMessage
+        # since it inherits from it, so we can use it directly
+        # Convert to dict and remove None values
+        message_dict = message.model_dump()
+        message_dict = {k: v for k, v in message_dict.items() if v is not None}
+        if model_name in (
+            "deepseek-r1-distill-llama-70b",
+            "openai/gpt-oss-120b",
+            "openai/gpt-oss-20b",
+        ):
+            message_dict.pop("reasoning", None)
+            message_dict.pop("channel", None)
+
+        messages.append(message_dict)
+        stop_reason = LlmStopReason.END_TURN
+        requested_tool_calls: Dict[str, CallToolRequest] | None = None
+        if await self._is_tool_stop_reason(choice.finish_reason) and message.tool_calls:
+            requested_tool_calls = {}
+            stop_reason = LlmStopReason.TOOL_USE
+            for tool_call in message.tool_calls:
+                tool_call_request = CallToolRequest(
+                    method="tools/call",
+                    params=CallToolRequestParams(
+                        name=tool_call.function.name,
+                        arguments={}
+                        if not tool_call.function.arguments
+                        or tool_call.function.arguments.strip() == ""
+                        else from_json(tool_call.function.arguments, allow_partial=True),
+                    ),
                 )
-                break
-            elif choice.finish_reason == "stop":
-                self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'stop'")
-                if message_text:
-                    await self.show_assistant_message(message_text, "")
-                break
+                requested_tool_calls[tool_call.id] = tool_call_request
+        elif choice.finish_reason == "length":
+            stop_reason = LlmStopReason.MAX_TOKENS
+            # We have reached the max tokens limit
+            self.logger.debug(" Stopping because finish_reason is 'length'")
+        elif choice.finish_reason == "content_filter":
+            stop_reason = LlmStopReason.SAFETY
+            self.logger.debug(" Stopping because finish_reason is 'content_filter'")
 
         if request_params.use_history:
             # Get current prompt messages
@@ -502,19 +434,21 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
         self._log_chat_finished(model=self.default_request_params.model)
 
-        return responses
+        return Prompt.assistant(
+            *response_content_blocks, stop_reason=stop_reason, tool_calls=requested_tool_calls
+        )
 
     async def _is_tool_stop_reason(self, finish_reason: str) -> bool:
         return True
 
     async def _apply_prompt_provider_specific(
         self,
-        multipart_messages: List["PromptMessageMultipart"],
+        multipart_messages: List["PromptMessageExtended"],
         request_params: RequestParams | None = None,
+        tools: List[Tool] | None = None,
         is_template: bool = False,
-    ) -> PromptMessageMultipart:
+    ) -> PromptMessageExtended:
         # Reset tool call counter for new turn
-        self._reset_turn_tool_calls()
 
         last_message = multipart_messages[-1]
 
@@ -525,29 +459,21 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         )
         converted = []
         for msg in messages_to_add:
-            converted.append(OpenAIConverter.convert_to_openai(msg))
+            # convert_to_openai now returns a list of messages
+            converted.extend(OpenAIConverter.convert_to_openai(msg))
 
-        # TODO -- this looks like a defect from previous apply_prompt implementation.
         self.history.extend(converted, is_prompt=is_template)
 
         if "assistant" == last_message.role:
             return last_message
 
-        # For assistant messages: Return the last message (no completion needed)
-        message_param: OpenAIMessage = OpenAIConverter.convert_to_openai(last_message)
-        responses: List[ContentBlock] = 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
+        converted_messages = OpenAIConverter.convert_to_openai(last_message)
+        if not converted_messages:
+            # Fallback for empty conversion
+            converted_messages = [{"role": "user", "content": ""}]
 
-    async def post_tool_call(
-        self, tool_call_id: str | None, request: CallToolRequest, result: CallToolResult
-    ):
-        return result
+        # Call completion without additional messages (all messages are now in history)
+        return await self._openai_completion(converted_messages, request_params, tools)
 
     def _prepare_api_request(
         self, messages, tools: List[ChatCompletionToolParam] | None, request_params: RequestParams

mcp_agent/llm/providers/augmented_llm_openrouter.py → fast_agent/llm/provider/openai/llm_openrouter.py

@@ -1,15 +1,15 @@
 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
 
 DEFAULT_OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
 # No single default model for OpenRouter, users must specify full path
 DEFAULT_OPENROUTER_MODEL = None
 
 
-class OpenRouterAugmentedLLM(OpenAIAugmentedLLM):
+class OpenRouterLLM(OpenAILLM):
     """Augmented LLM provider for OpenRouter, using an OpenAI-compatible API."""
 
     def __init__(self, *args, **kwargs) -> None:
@@ -19,7 +19,7 @@ class OpenRouterAugmentedLLM(OpenAIAugmentedLLM):
         """Initialize OpenRouter-specific default parameters."""
         # Get base defaults from parent (includes ModelDatabase lookup)
         base_params = super()._initialize_default_params(kwargs)
-        
+
         # Override with OpenRouter-specific settings
         # OpenRouter model names include the provider, e.g., "google/gemini-flash-1.5"
         # The model should be passed in the 'model' kwarg during factory creation.
@@ -28,7 +28,7 @@ class OpenRouterAugmentedLLM(OpenAIAugmentedLLM):
             base_params.model = chosen_model
         # If it's still None here, it indicates an issue upstream (factory or user input).
         # However, the base class _get_model handles the error if model is None.
-        
+
         return base_params
 
     def _base_url(self) -> str: