fast-agent-mcp 0.4.7__py3-none-any.whl

fast_agent/llm/provider/openai/llm_aliyun.py

@@ -0,0 +1,31 @@
+from fast_agent.llm.provider.openai.llm_groq import GroqLLM
+from fast_agent.llm.provider.openai.llm_openai import OpenAILLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.types import RequestParams
+
+ALIYUN_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+DEFAULT_QWEN_MODEL = "qwen-turbo"
+
+
+class AliyunLLM(GroqLLM):
+    def __init__(self, *args, **kwargs) -> None:
+        OpenAILLM.__init__(self, *args, provider=Provider.ALIYUN, **kwargs)
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """Initialize Aliyun-specific default parameters"""
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+
+        # Override with Aliyun-specific settings
+        chosen_model = kwargs.get("model", DEFAULT_QWEN_MODEL)
+        base_params.model = chosen_model
+        base_params.parallel_tool_calls = True
+
+        return base_params
+
+    def _base_url(self) -> str:
+        base_url = None
+        if self.context.config and self.context.config.aliyun:
+            base_url = self.context.config.aliyun.base_url
+
+        return base_url if base_url else ALIYUN_BASE_URL

fast_agent/llm/provider/openai/llm_azure.py

@@ -0,0 +1,143 @@
+from openai import AsyncAzureOpenAI, AsyncOpenAI, AuthenticationError
+
+from fast_agent.core.exceptions import ProviderKeyError
+from fast_agent.llm.provider.openai.llm_openai import OpenAILLM
+from fast_agent.llm.provider_types import Provider
+
+try:
+    from azure.identity import DefaultAzureCredential
+except ImportError:
+    DefaultAzureCredential = None
+
+
+def _extract_resource_name(url: str) -> str | None:
+    from urllib.parse import urlparse
+
+    host = urlparse(url).hostname or ""
+    suffix = ".openai.azure.com"
+    return host.replace(suffix, "") if host.endswith(suffix) else None
+
+
+DEFAULT_AZURE_API_VERSION = "2024-10-21"
+
+
+class AzureOpenAILLM(OpenAILLM):
+    """
+    Azure OpenAI implementation extending OpenAILLM.
+    Handles both API Key and DefaultAzureCredential authentication.
+    """
+
+    def __init__(self, provider: Provider = Provider.AZURE, *args, **kwargs):
+        # Set provider to AZURE, pass through to base
+        super().__init__(provider=provider, *args, **kwargs)
+
+        # Context/config extraction
+        context = getattr(self, "context", None)
+        config = getattr(context, "config", None) if context else None
+        azure_cfg = getattr(config, "azure", None) if config else None
+
+        if azure_cfg is None:
+            raise ProviderKeyError(
+                "Missing Azure configuration",
+                "Azure provider requires configuration section 'azure' in your config file.",
+            )
+
+        self.use_default_cred = getattr(azure_cfg, "use_default_azure_credential", False)
+        default_request_params = getattr(self, "default_request_params", None)
+        self.deployment_name = getattr(default_request_params, "model", None) or getattr(
+            azure_cfg, "azure_deployment", None
+        )
+        self.api_version = getattr(azure_cfg, "api_version", None) or DEFAULT_AZURE_API_VERSION
+
+        if self.use_default_cred:
+            self.base_url = getattr(azure_cfg, "base_url", None)
+            if not self.base_url:
+                raise ProviderKeyError(
+                    "Missing Azure endpoint",
+                    "When using 'use_default_azure_credential', 'base_url' is required in azure config.",
+                )
+            if DefaultAzureCredential is None:
+                raise ProviderKeyError(
+                    "azure-identity not installed",
+                    "You must install 'azure-identity' to use DefaultAzureCredential authentication.",
+                )
+            self.credential = DefaultAzureCredential()
+
+            def get_azure_token():
+                token = self.credential.get_token("https://cognitiveservices.azure.com/.default")
+                return token.token
+
+            self.get_azure_token = get_azure_token
+        else:
+            self.api_key = self._api_key()
+            self.resource_name = getattr(azure_cfg, "resource_name", None)
+            self.base_url = getattr(azure_cfg, "base_url", None) or (
+                f"https://{self.resource_name}.openai.azure.com/" if self.resource_name else None
+            )
+            if not self.api_key:
+                raise ProviderKeyError(
+                    "Missing Azure OpenAI credentials",
+                    "Field 'api_key' is required in azure config.",
+                )
+            if not (self.resource_name or self.base_url):
+                raise ProviderKeyError(
+                    "Missing Azure endpoint",
+                    "Provide either 'resource_name' or 'base_url' under azure config.",
+                )
+            if not self.deployment_name:
+                raise ProviderKeyError(
+                    "Missing deployment name",
+                    "Set 'azure_deployment' in config or pass model=<deployment>.",
+                )
+            # If resource_name was missing, try to extract it from base_url
+            if not self.resource_name and self.base_url:
+                self.resource_name = _extract_resource_name(self.base_url)
+
+    def _api_key(self):
+        """Override to return 'AzureCredential' when using DefaultAzureCredential"""
+        if self.use_default_cred:
+            return "AzureCredential"
+        return super()._api_key()
+
+    def _openai_client(self) -> AsyncOpenAI:
+        """
+        Returns an AzureOpenAI client, handling both API Key and DefaultAzureCredential.
+        """
+        try:
+            if self.use_default_cred:
+                if self.base_url is None:
+                    raise ProviderKeyError(
+                        "Missing Azure endpoint",
+                        "azure_endpoint (base_url) is None at client creation time.",
+                    )
+                return AsyncAzureOpenAI(
+                    azure_ad_token_provider=self.get_azure_token,
+                    azure_endpoint=self.base_url,
+                    api_version=self.api_version,
+                    azure_deployment=self.deployment_name,
+                )
+            else:
+                if self.base_url is None:
+                    raise ProviderKeyError(
+                        "Missing Azure endpoint",
+                        "azure_endpoint (base_url) is None at client creation time.",
+                    )
+                return AsyncAzureOpenAI(
+                    api_key=self.api_key,
+                    azure_endpoint=self.base_url,
+                    api_version=self.api_version,
+                    azure_deployment=self.deployment_name,
+                )
+        except AuthenticationError as e:
+            if self.use_default_cred:
+                raise ProviderKeyError(
+                    "Invalid Azure AD credentials",
+                    "The configured Azure AD credentials were rejected.\n"
+                    "Please check your Azure identity setup.",
+                ) from e
+            else:
+                raise ProviderKeyError(
+                    "Invalid Azure OpenAI API key",
+                    "The configured Azure OpenAI API key was rejected.\n"
+                    "Please check that your API key is valid and not expired.",
+                ) from e

fast_agent/llm/provider/openai/llm_deepseek.py

@@ -0,0 +1,76 @@
+from copy import copy
+from typing import Type, cast
+
+from openai.types.chat import (
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionMessage,
+)
+
+from fast_agent.interfaces import ModelT
+from fast_agent.llm.provider.openai.llm_openai_compatible import OpenAICompatibleLLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.types import RequestParams
+
+DEEPSEEK_BASE_URL = "https://api.deepseek.com"
+DEFAULT_DEEPSEEK_MODEL = "deepseekchat"  # current Deepseek only has two type models
+
+
+class DeepSeekLLM(OpenAICompatibleLLM):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, provider=Provider.DEEPSEEK, **kwargs)
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """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:
+        base_url = None
+        if self.context.config and self.context.config.deepseek:
+            base_url = self.context.config.deepseek.base_url
+
+        return base_url if base_url else DEEPSEEK_BASE_URL
+
+    def _build_structured_prompt_instruction(self, model: Type[ModelT]) -> str | None:
+        full_schema = model.model_json_schema()
+        properties = full_schema.get("properties", {})
+        required_fields = set(full_schema.get("required", []))
+
+        format_lines = ["{"] 
+        for field_name, field_info in properties.items():
+            field_type = field_info.get("type", "string")
+            description = field_info.get("description", "")
+            line = f'  "{field_name}": "{field_type}"'
+            if description:
+                line += f"  // {description}"
+            if field_name in required_fields:
+                line += "  // REQUIRED"
+            format_lines.append(line)
+        format_lines.append("}")
+        format_description = "\n".join(format_lines)
+
+        return f"""YOU MUST RESPOND WITH A JSON OBJECT IN EXACTLY THIS FORMAT:
+{format_description}
+
+IMPORTANT RULES:
+- Respond ONLY with the JSON object, no other text
+- 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"""
+
+    @classmethod
+    def convert_message_to_message_param(
+        cls, message: ChatCompletionMessage, **kwargs
+    ) -> ChatCompletionAssistantMessageParam:
+        """Convert a response object to an input parameter object to allow LLM calls to be chained."""
+        if hasattr(message, "reasoning_content"):
+            message = copy(message)
+            del message.reasoning_content
+        return cast("ChatCompletionAssistantMessageParam", message)

fast_agent/llm/provider/openai/llm_generic.py

@@ -0,0 +1,35 @@
+import os
+
+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 GenericLLM(OpenAILLM):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(
+            *args, provider=Provider.GENERIC, **kwargs
+        )  # Properly pass args and kwargs to parent
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """Initialize Generic  parameters"""
+        chosen_model = kwargs.get("model", DEFAULT_OLLAMA_MODEL)
+
+        return RequestParams(
+            model=chosen_model,
+            systemPrompt=self.instruction,
+            parallel_tool_calls=True,
+            max_iterations=10,
+            use_history=True,
+        )
+
+    def _base_url(self) -> str:
+        base_url = os.getenv("GENERIC_BASE_URL", DEFAULT_OLLAMA_BASE_URL)
+        if self.context.config and self.context.config.generic:
+            base_url = self.context.config.generic.base_url
+
+        return base_url

fast_agent/llm/provider/openai/llm_google_oai.py

@@ -0,0 +1,32 @@
+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 GoogleOaiLLM(OpenAILLM):
+    config_section = "google"
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, provider=Provider.GOOGLE_OAI, **kwargs)
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """Initialize Google OpenAI Compatibility default parameters"""
+        chosen_model = kwargs.get("model", DEFAULT_GOOGLE_MODEL)
+
+        return RequestParams(
+            model=chosen_model,
+            systemPrompt=self.instruction,
+            parallel_tool_calls=False,
+            max_iterations=20,
+            use_history=True,
+        )
+
+    def _base_url(self) -> str:
+        base_url = None
+        if self.context.config and self.context.config.google:
+            base_url = self.context.config.google.base_url
+
+        return base_url if base_url else GOOGLE_BASE_URL

fast_agent/llm/provider/openai/llm_groq.py

@@ -0,0 +1,42 @@
+from fast_agent.llm.model_database import ModelDatabase
+from fast_agent.llm.provider.openai.llm_openai_compatible import OpenAICompatibleLLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.types import RequestParams
+
+GROQ_BASE_URL = "https://api.groq.com/openai/v1"
+DEFAULT_GROQ_MODEL = "moonshotai/kimi-k2-instruct"
+
+### There is some big refactorings to be had quite easily here now:
+### - combining the structured output type handling
+### - deduplicating between this and the deepseek llm
+
+
+class GroqLLM(OpenAICompatibleLLM):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, provider=Provider.GROQ, **kwargs)
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """Initialize Groq default parameters"""
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+
+        # Override with Groq-specific settings
+        chosen_model = kwargs.get("model", DEFAULT_GROQ_MODEL)
+        base_params.model = chosen_model
+        base_params.parallel_tool_calls = False
+
+        return base_params
+
+    def _supports_structured_prompt(self) -> bool:
+        llm_model = (
+            self.default_request_params.model if self.default_request_params else DEFAULT_GROQ_MODEL
+        )
+        json_mode: str | None = ModelDatabase.get_json_mode(llm_model)
+        return json_mode == "object"
+
+    def _base_url(self) -> str:
+        base_url = None
+        if self.context.config and self.context.config.groq:
+            base_url = self.context.config.groq.base_url
+
+        return base_url if base_url else GROQ_BASE_URL

fast_agent/llm/provider/openai/llm_huggingface.py

@@ -0,0 +1,85 @@
+import os
+
+from fast_agent.llm.provider.openai.llm_openai_compatible import OpenAICompatibleLLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.types import RequestParams
+
+HUGGINGFACE_BASE_URL = "https://router.huggingface.co/v1"
+DEFAULT_HUGGINGFACE_MODEL = "moonshotai/Kimi-K2-Instruct-0905"
+
+
+class HuggingFaceLLM(OpenAICompatibleLLM):
+    def __init__(self, *args, **kwargs) -> None:
+        self._hf_provider_suffix: str | None = None
+        super().__init__(*args, provider=Provider.HUGGINGFACE, **kwargs)
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """Initialize HuggingFace-specific default parameters"""
+        kwargs = kwargs.copy()
+        requested_model = kwargs.get("model") or DEFAULT_HUGGINGFACE_MODEL
+        base_model, explicit_provider = self._split_provider_suffix(requested_model)
+        base_model = base_model or requested_model
+        kwargs["model"] = base_model
+
+        # Determine which provider suffix to use
+        provider_suffix = explicit_provider or self._resolve_default_provider()
+        self._hf_provider_suffix = provider_suffix
+
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+
+        # Override with HuggingFace-specific settings
+        base_params.model = base_model
+        base_params.parallel_tool_calls = True
+
+        return base_params
+
+    def _base_url(self) -> str:
+        base_url = None
+        if self.context.config and self.context.config.hf:
+            base_url = self.context.config.hf.base_url
+
+        return base_url if base_url else HUGGINGFACE_BASE_URL
+
+    def _prepare_api_request(
+        self, messages, tools: list | None, request_params: RequestParams
+    ) -> dict[str, str]:
+        arguments = super()._prepare_api_request(messages, tools, request_params)
+        model_name = arguments.get("model")
+        base_model, explicit_provider = self._split_provider_suffix(model_name)
+        base_model = base_model or model_name
+        if not base_model:
+            return arguments
+
+        provider_suffix = explicit_provider or self._hf_provider_suffix
+        if provider_suffix:
+            arguments["model"] = f"{base_model}:{provider_suffix}"
+        else:
+            arguments["model"] = base_model
+        return arguments
+
+    def _resolve_default_provider(self) -> str | None:
+        config_provider = None
+        if self.context and self.context.config and self.context.config.hf:
+            config_provider = self.context.config.hf.default_provider
+        env_provider = os.getenv("HF_DEFAULT_PROVIDER")
+        return config_provider or env_provider
+
+    @staticmethod
+    def _split_provider_suffix(model: str | None) -> tuple[str | None, str | None]:
+        if not model or ":" not in model:
+            return model, None
+        base, suffix = model.rsplit(":", 1)
+        if not base:
+            return model, None
+        return base, suffix or None
+
+    def get_hf_display_info(self) -> dict[str, str]:
+        """Return display information for HuggingFace model and provider.
+
+        Returns:
+            dict with 'model' and 'provider' keys
+        """
+        model = self.default_request_params.model if self.default_request_params else None
+        provider = self._hf_provider_suffix or "auto-routing"
+        return {"model": model or DEFAULT_HUGGINGFACE_MODEL, "provider": provider}