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

{mcp_agent → fast_agent}/llm/model_factory.py

@@ -1,51 +1,22 @@
 from enum import Enum
-from typing import Callable, Dict, Optional, Type, Union
+from typing import Dict, Optional, Type, Union
 
 from pydantic import BaseModel
 
-from mcp_agent.agents.agent import Agent
-from mcp_agent.core.exceptions import ModelConfigError
-from mcp_agent.core.request_params import RequestParams
-from mcp_agent.llm.augmented_llm_passthrough import PassthroughLLM
-from mcp_agent.llm.augmented_llm_playback import PlaybackLLM
-from mcp_agent.llm.augmented_llm_silent import SilentLLM
-from mcp_agent.llm.augmented_llm_slow import SlowLLM
-from mcp_agent.llm.provider_types import Provider
-from mcp_agent.llm.providers.augmented_llm_aliyun import AliyunAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_anthropic import AnthropicAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_azure import AzureOpenAIAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_bedrock import BedrockAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_deepseek import DeepSeekAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_generic import GenericAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_google_native import GoogleNativeAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_google_oai import GoogleOaiAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_groq import GroqAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_openrouter import OpenRouterAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_tensorzero_openai import TensorZeroOpenAIAugmentedLLM
-from mcp_agent.llm.providers.augmented_llm_xai import XAIAugmentedLLM
-from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
-
-# from mcp_agent.workflows.llm.augmented_llm_deepseek import DeekSeekAugmentedLLM
+from fast_agent.core.exceptions import ModelConfigError
+from fast_agent.interfaces import AgentProtocol, FastAgentLLMProtocol, LLMFactoryProtocol
+from fast_agent.llm.internal.passthrough import PassthroughLLM
+from fast_agent.llm.internal.playback import PlaybackLLM
+from fast_agent.llm.internal.silent import SilentLLM
+from fast_agent.llm.internal.slow import SlowLLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.types import RequestParams
+
+# from fast_agent.workflows.llm.augmented_llm_deepseek import DeekSeekAugmentedLLM
 
 
 # Type alias for LLM classes
-LLMClass = Union[
-    Type[AnthropicAugmentedLLM],
-    Type[OpenAIAugmentedLLM],
-    Type[PassthroughLLM],
-    Type[PlaybackLLM],
-    Type[SilentLLM],
-    Type[SlowLLM],
-    Type[DeepSeekAugmentedLLM],
-    Type[OpenRouterAugmentedLLM],
-    Type[TensorZeroOpenAIAugmentedLLM],
-    Type[GoogleNativeAugmentedLLM],
-    Type[GenericAugmentedLLM],
-    Type[AzureOpenAIAugmentedLLM],
-    Type[BedrockAugmentedLLM],
-    Type[GroqAugmentedLLM],
-]
+LLMClass = Union[Type[PassthroughLLM], Type[PlaybackLLM], Type[SilentLLM], Type[SlowLLM], type]
 
 
 class ReasoningEffort(Enum):
@@ -78,7 +49,6 @@ class ModelFactory:
     }
 
     """
-    TODO -- add context window size information for display/management
     TODO -- add audio supporting got-4o-audio-preview
     TODO -- bring model parameter configuration here
     Mapping of model names to their default providers
@@ -150,28 +120,26 @@ class ModelFactory:
         "gemini2": "gemini-2.0-flash",
         "gemini25": "gemini-2.5-flash-preview-05-20",
         "gemini25pro": "gemini-2.5-pro-preview-05-06",
-        "kimi": "groq.moonshotai/kimi-k2-instruct",
+        "kimi": "groq.moonshotai/kimi-k2-instruct-0905",
         "gpt-oss": "groq.openai/gpt-oss-120b",
         "gpt-oss-20b": "groq.openai/gpt-oss-20b",
     }
 
+    @staticmethod
+    def _bedrock_pattern_matches(model_name: str) -> bool:
+        """Return True if model_name matches Bedrock's expected pattern, else False.
+
+        Uses provider's helper if available; otherwise, returns False.
+        """
+        try:
+            from fast_agent.llm.provider.bedrock.llm_bedrock import BedrockLLM  # type: ignore
+
+            return BedrockLLM.matches_model_pattern(model_name)
+        except Exception:
+            return False
+
     # Mapping of providers to their LLM classes
-    PROVIDER_CLASSES: Dict[Provider, LLMClass] = {
-        Provider.ANTHROPIC: AnthropicAugmentedLLM,
-        Provider.OPENAI: OpenAIAugmentedLLM,
-        Provider.FAST_AGENT: PassthroughLLM,
-        Provider.DEEPSEEK: DeepSeekAugmentedLLM,
-        Provider.GENERIC: GenericAugmentedLLM,
-        Provider.GOOGLE_OAI: GoogleOaiAugmentedLLM,
-        Provider.GOOGLE: GoogleNativeAugmentedLLM,
-        Provider.XAI: XAIAugmentedLLM,
-        Provider.OPENROUTER: OpenRouterAugmentedLLM,
-        Provider.TENSORZERO: TensorZeroOpenAIAugmentedLLM,
-        Provider.AZURE: AzureOpenAIAugmentedLLM,
-        Provider.ALIYUN: AliyunAugmentedLLM,
-        Provider.BEDROCK: BedrockAugmentedLLM,
-        Provider.GROQ: GroqAugmentedLLM,
-    }
+    PROVIDER_CLASSES: Dict[Provider, LLMClass] = {}
 
     # Mapping of special model names to their specific LLM classes
     # This overrides the provider-based class selection
@@ -227,7 +195,7 @@ class ModelFactory:
             provider = cls.DEFAULT_PROVIDERS.get(model_name_str)
 
             # If still None, try pattern matching for Bedrock models
-            if provider is None and BedrockAugmentedLLM.matches_model_pattern(model_name_str):
+            if provider is None and cls._bedrock_pattern_matches(model_name_str):
                 provider = Provider.BEDROCK
 
             if provider is None:
@@ -246,15 +214,12 @@ class ModelFactory:
         )
 
     @classmethod
-    def create_factory(
-        cls, model_string: str, request_params: Optional[RequestParams] = None
-    ) -> Callable[..., AugmentedLLMProtocol]:
+    def create_factory(cls, model_string: str) -> LLMFactoryProtocol:
         """
         Creates a factory function that follows the attach_llm protocol.
 
         Args:
             model_string: The model specification string (e.g. "gpt-4.1")
-            request_params: Optional parameters to configure LLM behavior
 
         Returns:
             A callable that takes an agent parameter and returns an LLM instance
@@ -262,35 +227,96 @@ class ModelFactory:
         config = cls.parse_model_string(model_string)
 
         # Ensure provider is valid before trying to access PROVIDER_CLASSES with it
-        if (
-            config.provider not in cls.PROVIDER_CLASSES
-            and config.model_name not in cls.MODEL_SPECIFIC_CLASSES
-        ):
-            # This check is important if a provider (like old GOOGLE) is commented out from PROVIDER_CLASSES
-            raise ModelConfigError(
-                f"Provider '{config.provider}' not configured in PROVIDER_CLASSES and model '{config.model_name}' not in MODEL_SPECIFIC_CLASSES."
-            )
+        # Lazily ensure provider class map is populated and supports this provider
+        if config.model_name not in cls.MODEL_SPECIFIC_CLASSES:
+            llm_class = cls._load_provider_class(config.provider)
+            # Stash for next time
+            cls.PROVIDER_CLASSES[config.provider] = llm_class
 
         if config.model_name in cls.MODEL_SPECIFIC_CLASSES:
             llm_class = cls.MODEL_SPECIFIC_CLASSES[config.model_name]
         else:
-            # This line is now safer due to the check above
             llm_class = cls.PROVIDER_CLASSES[config.provider]
 
         def factory(
-            agent: Agent, request_params: Optional[RequestParams] = None, **kwargs
-        ) -> AugmentedLLMProtocol:
+            agent: AgentProtocol, request_params: Optional[RequestParams] = None, **kwargs
+        ) -> FastAgentLLMProtocol:
             base_params = RequestParams()
             base_params.model = config.model_name
             if config.reasoning_effort:
                 kwargs["reasoning_effort"] = config.reasoning_effort.value
             llm_args = {
-                "agent": agent,
                 "model": config.model_name,
                 "request_params": request_params,
+                "name": agent.name,
+                "instructions": agent.instruction,
                 **kwargs,
             }
-            llm: AugmentedLLMProtocol = llm_class(**llm_args)
+            llm: FastAgentLLMProtocol = llm_class(**llm_args)
             return llm
 
         return factory
+
+    @classmethod
+    def _load_provider_class(cls, provider: Provider) -> type:
+        """Import provider-specific LLM classes lazily to avoid heavy deps at import time."""
+        try:
+            if provider == Provider.FAST_AGENT:
+                return PassthroughLLM
+            if provider == Provider.ANTHROPIC:
+                from fast_agent.llm.provider.anthropic.llm_anthropic import AnthropicLLM
+
+                return AnthropicLLM
+            if provider == Provider.OPENAI:
+                from fast_agent.llm.provider.openai.llm_openai import OpenAILLM
+
+                return OpenAILLM
+            if provider == Provider.DEEPSEEK:
+                from fast_agent.llm.provider.openai.llm_deepseek import DeepSeekLLM
+
+                return DeepSeekLLM
+            if provider == Provider.GENERIC:
+                from fast_agent.llm.provider.openai.llm_generic import GenericLLM
+
+                return GenericLLM
+            if provider == Provider.GOOGLE_OAI:
+                from fast_agent.llm.provider.openai.llm_google_oai import GoogleOaiLLM
+
+                return GoogleOaiLLM
+            if provider == Provider.GOOGLE:
+                from fast_agent.llm.provider.google.llm_google_native import GoogleNativeLLM
+
+                return GoogleNativeLLM
+            if provider == Provider.XAI:
+                from fast_agent.llm.provider.openai.llm_xai import XAILLM
+
+                return XAILLM
+            if provider == Provider.OPENROUTER:
+                from fast_agent.llm.provider.openai.llm_openrouter import OpenRouterLLM
+
+                return OpenRouterLLM
+            if provider == Provider.TENSORZERO:
+                from fast_agent.llm.provider.openai.llm_tensorzero_openai import TensorZeroOpenAILLM
+
+                return TensorZeroOpenAILLM
+            if provider == Provider.AZURE:
+                from fast_agent.llm.provider.openai.llm_azure import AzureOpenAILLM
+
+                return AzureOpenAILLM
+            if provider == Provider.ALIYUN:
+                from fast_agent.llm.provider.openai.llm_aliyun import AliyunLLM
+
+                return AliyunLLM
+            if provider == Provider.BEDROCK:
+                from fast_agent.llm.provider.bedrock.llm_bedrock import BedrockLLM
+
+                return BedrockLLM
+            if provider == Provider.GROQ:
+                from fast_agent.llm.provider.openai.llm_groq import GroqLLM
+
+                return GroqLLM
+        except Exception as e:
+            raise ModelConfigError(
+                f"Provider '{provider.value}' is unavailable or missing dependencies: {e}"
+            )
+        raise ModelConfigError(f"Unsupported provider: {provider}")

fast_agent/llm/model_info.py

@@ -0,0 +1,126 @@
+"""
+Typed model information helpers.
+
+Provides a small, pythonic interface to query model/provider and
+capabilities (Text/Document/Vision), backed by the model database.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from fast_agent.llm.model_database import ModelDatabase
+from fast_agent.llm.provider_types import Provider
+
+if TYPE_CHECKING:
+    # Import behind TYPE_CHECKING to avoid import cycles at runtime
+    from fast_agent.interfaces import AgentProtocol, FastAgentLLMProtocol
+
+
+@dataclass(frozen=True)
+class ModelInfo:
+    """Resolved model information with convenient capability accessors."""
+
+    name: str
+    provider: Provider
+    context_window: Optional[int]
+    max_output_tokens: Optional[int]
+    tokenizes: List[str]
+    json_mode: Optional[str]
+    reasoning: Optional[str]
+
+    @property
+    def supports_text(self) -> bool:
+        return ModelDatabase.supports_mime(self.name, "text/plain")
+
+    @property
+    def supports_document(self) -> bool:
+        # Document support currently keyed off PDF support
+        return ModelDatabase.supports_mime(self.name, "pdf")
+
+    @property
+    def supports_vision(self) -> bool:
+        # Any common image format indicates vision support
+        return any(
+            ModelDatabase.supports_mime(self.name, mt)
+            for mt in ("image/jpeg", "image/png", "image/webp")
+        )
+
+    @property
+    def tdv_flags(self) -> tuple[bool, bool, bool]:
+        """Convenience tuple: (text, document, vision)."""
+        return (self.supports_text, self.supports_document, self.supports_vision)
+
+    @classmethod
+    def from_llm(cls, llm: "FastAgentLLMProtocol") -> Optional["ModelInfo"]:
+        name = getattr(llm, "model_name", None)
+        provider = getattr(llm, "provider", None)
+        if not name or not provider:
+            return None
+        return cls.from_name(name, provider)
+
+    @classmethod
+    def from_name(cls, name: str, provider: Provider | None = None) -> Optional["ModelInfo"]:
+        params = ModelDatabase.get_model_params(name)
+        if not params:
+            # Unknown model: return a conservative default that supports text only.
+            # This matches the desired behavior for TDV display fallbacks.
+            if provider is None:
+                provider = Provider.GENERIC
+            return ModelInfo(
+                name=name,
+                provider=provider,
+                context_window=None,
+                max_output_tokens=None,
+                tokenizes=["text/plain"],
+                json_mode=None,
+                reasoning=None,
+            )
+
+        return ModelInfo(
+            name=name,
+            provider=provider or Provider.GENERIC,
+            context_window=params.context_window,
+            max_output_tokens=params.max_output_tokens,
+            tokenizes=params.tokenizes,
+            json_mode=params.json_mode,
+            reasoning=params.reasoning,
+        )
+
+
+def get_model_info(
+    subject: Union["AgentProtocol", "FastAgentLLMProtocol", str, None],
+    provider: Provider | None = None,
+) -> Optional[ModelInfo]:
+    """Resolve a ModelInfo from an Agent, LLM, or model name.
+
+    Keeps the public API small while enabling type-safe access to model
+    capabilities across the codebase.
+    """
+    if subject is None:
+        return None
+
+    # Agent → LLM
+    try:
+        from fast_agent.interfaces import AgentProtocol as _AgentProtocol
+    except Exception:
+        _AgentProtocol = None  # type: ignore
+
+    if _AgentProtocol and isinstance(subject, _AgentProtocol):  # type: ignore[arg-type]
+        return ModelInfo.from_llm(subject.llm)
+
+    # LLM → ModelInfo
+    try:
+        from fast_agent.interfaces import FastAgentLLMProtocol as _LLMProtocol
+    except Exception:
+        _LLMProtocol = None  # type: ignore
+
+    if _LLMProtocol and isinstance(subject, _LLMProtocol):  # type: ignore[arg-type]
+        return ModelInfo.from_llm(subject)
+
+    # String model name
+    if isinstance(subject, str):
+        return ModelInfo.from_name(subject, provider)
+
+    return None

{mcp_agent/llm/providers → fast_agent/llm/provider/anthropic}/anthropic_utils.py

@@ -1,7 +1,7 @@
 """
 Utility functions for Anthropic integration with MCP.
 
-Provides conversion between Anthropic message formats and PromptMessageMultipart,
+Provides conversion between Anthropic message formats and PromptMessageExtended,
 leveraging existing code for resource handling and delimited formats.
 """
 
@@ -15,28 +15,28 @@ from mcp.types import (
     TextResourceContents,
 )
 
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.types import PromptMessageExtended
 
 
 # TODO -- only used for saving, but this will be driven directly from PromptMessages
 def anthropic_message_param_to_prompt_message_multipart(
     message_param: MessageParam,
-) -> PromptMessageMultipart:
+) -> PromptMessageExtended:
     """
-    Convert an Anthropic MessageParam to a PromptMessageMultipart.
+    Convert an Anthropic MessageParam to a PromptMessageExtended.
 
     Args:
         message_param: The Anthropic MessageParam to convert
 
     Returns:
-        A PromptMessageMultipart representation
+        A PromptMessageExtended representation
     """
     role = message_param["role"]
     content = message_param["content"]
 
     # Handle string content (user messages can be simple strings)
     if isinstance(content, str):
-        return PromptMessageMultipart(role=role, content=[TextContent(type="text", text=content)])
+        return PromptMessageExtended(role=role, content=[TextContent(type="text", text=content)])
 
     # Convert content blocks to MCP content types
     mcp_contents = []
@@ -81,4 +81,4 @@ def anthropic_message_param_to_prompt_message_multipart(
                     data = source.get("data", "")
                     mcp_contents.append(ImageContent(type="image", data=data, mimeType=media_type))
 
-    return PromptMessageMultipart(role=role, content=mcp_contents)
+    return PromptMessageExtended(role=role, content=mcp_contents)