lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/base/embeddings/embeddings_class.py

@@ -0,0 +1,113 @@
+"""Extended embeddings class with available models metadata."""
+
+from langchain_core.embeddings import Embeddings
+
+
+class EmbeddingsWithModels(Embeddings):
+    """Extended Embeddings class that includes available models with dedicated instances.
+
+    This class inherits from LangChain Embeddings and provides a mapping of model names
+    to their dedicated embedding instances, enabling multi-model support without the need
+    for dynamic model switching.
+
+    Attributes:
+        embeddings: The primary LangChain Embeddings instance (used as fallback).
+        available_models: Dict mapping model names to their dedicated Embeddings instances.
+                         Each model has its own pre-configured instance with specific parameters.
+    """
+
+    def __init__(
+        self,
+        embeddings: Embeddings,
+        available_models: dict[str, Embeddings] | None = None,
+    ):
+        """Initialize the EmbeddingsWithModels wrapper.
+
+        Args:
+            embeddings: The primary LangChain Embeddings instance (used as default/fallback).
+            available_models: Dict mapping model names to dedicated Embeddings instances.
+                            Each value should be a fully configured Embeddings object ready to use.
+                            Defaults to empty dict if not provided.
+        """
+        super().__init__()
+        self.embeddings = embeddings
+        self.available_models = available_models if available_models is not None else {}
+
+    def embed_documents(self, texts: list[str]) -> list[list[float]]:
+        """Embed search docs by delegating to the underlying embeddings instance.
+
+        Args:
+            texts: List of text to embed.
+
+        Returns:
+            List of embeddings.
+        """
+        return self.embeddings.embed_documents(texts)
+
+    def embed_query(self, text: str) -> list[float]:
+        """Embed query text by delegating to the underlying embeddings instance.
+
+        Args:
+            text: Text to embed.
+
+        Returns:
+            Embedding.
+        """
+        return self.embeddings.embed_query(text)
+
+    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
+        """Asynchronously embed search docs.
+
+        Args:
+            texts: List of text to embed.
+
+        Returns:
+            List of embeddings.
+        """
+        return await self.embeddings.aembed_documents(texts)
+
+    async def aembed_query(self, text: str) -> list[float]:
+        """Asynchronously embed query text.
+
+        Args:
+            text: Text to embed.
+
+        Returns:
+            Embedding.
+        """
+        return await self.embeddings.aembed_query(text)
+
+    def __call__(self, *args, **kwargs):
+        """Make the class callable by delegating to the underlying embeddings instance.
+
+        This handles cases where the embeddings object is used as a callable.
+
+        Args:
+            *args: Positional arguments to pass to the underlying embeddings instance.
+            **kwargs: Keyword arguments to pass to the underlying embeddings instance.
+
+        Returns:
+            The result of calling the underlying embeddings instance.
+        """
+        if callable(self.embeddings):
+            return self.embeddings(*args, **kwargs)
+        msg = f"'{type(self.embeddings).__name__}' object is not callable"
+        raise TypeError(msg)
+
+    def __getattr__(self, name: str):
+        """Delegate attribute access to the underlying embeddings instance.
+
+        This ensures full compatibility with any additional methods or attributes
+        that the underlying embeddings instance might have.
+
+        Args:
+            name: The attribute name to access.
+
+        Returns:
+            The attribute from the underlying embeddings instance.
+        """
+        return getattr(self.embeddings, name)
+
+    def __repr__(self) -> str:
+        """Return string representation of the wrapper."""
+        return f"EmbeddingsWithModels(embeddings={self.embeddings!r}, available_models={self.available_models!r})"

lfx/base/models/groq_constants.py

@@ -1,87 +1,91 @@
 from .model_metadata import create_model_metadata
 
-# Unified model metadata - single source of truth
+# Unified model metadata
+#
+# NOTE: This file serves as a FALLBACK when the dynamic model discovery system
+# (groq_model_discovery.py) cannot fetch fresh data from the Groq API.
+#
+# The dynamic system is the PRIMARY source and will:
+# - Fetch available models directly from Groq API
+# - Test each model for tool calling support automatically
+# - Cache results for 24 hours
+# - Always provide up-to-date model lists
+#
+# This fallback list should contain:
+# - Minimal set of stable production models
+# - Deprecated models for backwards compatibility
+# - Non-LLM models (audio, TTS) marked as not_supported
+#
+# Last manually updated: 2025-01-06
+#
 GROQ_MODELS_DETAILED = [
-    # Production Models - Stable and reliable for production use
-    create_model_metadata(  # Google
-        provider="Groq", name="gemma2-9b-it", icon="Groq", tool_calling=True
-    ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama-3.3-70b-versatile", icon="Groq", tool_calling=True
-    ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama-3.1-8b-instant", icon="Groq"
-    ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama-guard-3-8b", icon="Groq"
+    # ===== FALLBACK PRODUCTION MODELS =====
+    # These are stable models that are very unlikely to be removed
+    create_model_metadata(provider="Groq", name="llama-3.1-8b-instant", icon="Groq", tool_calling=True),
+    create_model_metadata(provider="Groq", name="llama-3.3-70b-versatile", icon="Groq", tool_calling=True),
+    # ===== DEPRECATED MODELS =====
+    # Keep these for backwards compatibility - users may have flows using them
+    # These will appear in the list but show as deprecated in the UI
+    create_model_metadata(  # Google - Removed
+        provider="Groq", name="gemma2-9b-it", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama3-70b-8192", icon="Groq"
-    ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama3-8b-8192", icon="Groq"
-    ),
-    # Preview Models - For evaluation purposes only
-    create_model_metadata(  # Meta
-        provider="Groq", name="meta-llama/llama-4-scout-17b-16e-instruct", icon="Groq", tool_calling=True, preview=True
+    create_model_metadata(  # Google
+        provider="Groq", name="gemma-7b-it", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Meta
-        provider="Groq",
-        name="meta-llama/llama-4-maverick-17b-128e-instruct",
-        icon="Groq",
-        tool_calling=True,
-        preview=True,
+    create_model_metadata(  # Meta - Removed
+        provider="Groq", name="llama3-70b-8192", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Alibaba Cloud
-        provider="Groq", name="qwen-qwq-32b", icon="Groq", tool_calling=True, preview=True
+    create_model_metadata(  # Meta - Removed
+        provider="Groq", name="llama3-8b-8192", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Alibaba Cloud
-        provider="Groq", name="qwen-2.5-coder-32b", icon="Groq", tool_calling=True, preview=True
+    create_model_metadata(  # Meta - Removed, replaced by llama-guard-4-12b
+        provider="Groq", name="llama-guard-3-8b", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Alibaba Cloud
-        provider="Groq", name="qwen-2.5-32b", icon="Groq", tool_calling=True, preview=True
+    create_model_metadata(  # Meta - Removed
+        provider="Groq", name="llama-3.2-1b-preview", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # DeepSeek
-        provider="Groq", name="deepseek-r1-distill-qwen-32b", icon="Groq", tool_calling=True, preview=True
+    create_model_metadata(  # Meta - Removed
+        provider="Groq", name="llama-3.2-3b-preview", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # DeepSeek
-        provider="Groq", name="deepseek-r1-distill-llama-70b", icon="Groq", preview=True
+    create_model_metadata(  # Meta - Removed
+        provider="Groq", name="llama-3.2-11b-vision-preview", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama-3.3-70b-specdec", icon="Groq", tool_calling=True, preview=True
+    create_model_metadata(  # Meta - Removed
+        provider="Groq", name="llama-3.2-90b-vision-preview", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama-3.2-1b-preview", icon="Groq", tool_calling=True, preview=True
+    create_model_metadata(  # Meta - Removed
+        provider="Groq", name="llama-3.3-70b-specdec", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama-3.2-3b-preview", icon="Groq", tool_calling=True, preview=True
+    create_model_metadata(  # Alibaba - Removed, replaced by qwen/qwen3-32b
+        provider="Groq", name="qwen-qwq-32b", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama-3.2-11b-vision-preview", icon="Groq", preview=True
+    create_model_metadata(  # Alibaba - Removed
+        provider="Groq", name="qwen-2.5-coder-32b", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Meta
-        provider="Groq", name="llama-3.2-90b-vision-preview", icon="Groq", tool_calling=True, preview=True
+    create_model_metadata(  # Alibaba - Removed
+        provider="Groq", name="qwen-2.5-32b", icon="Groq", deprecated=True
     ),
-    create_model_metadata(  # Saudi Data and AI Authority (SDAIA)
-        provider="Groq", name="allam-2-7b", icon="Groq", preview=True
+    create_model_metadata(  # DeepSeek - Removed
+        provider="Groq", name="deepseek-r1-distill-qwen-32b", icon="Groq", deprecated=True
     ),
-    # Deprecated Models - Previously available but now removed
-    create_model_metadata(  # Google
-        provider="Groq", name="gemma-7b-it", icon="Groq", tool_calling=True, deprecated=True
+    create_model_metadata(  # DeepSeek - Removed
+        provider="Groq", name="deepseek-r1-distill-llama-70b", icon="Groq", deprecated=True
     ),
     create_model_metadata(  # Groq
-        provider="Groq", name="llama3-groq-70b-8192-tool-use-preview", icon="Groq", tool_calling=True, deprecated=True
+        provider="Groq", name="llama3-groq-70b-8192-tool-use-preview", icon="Groq", deprecated=True
     ),
     create_model_metadata(  # Groq
-        provider="Groq", name="llama3-groq-8b-8192-tool-use-preview", icon="Groq", tool_calling=True, deprecated=True
+        provider="Groq", name="llama3-groq-8b-8192-tool-use-preview", icon="Groq", deprecated=True
     ),
     create_model_metadata(  # Meta
-        provider="Groq", name="llama-3.1-70b-versatile", icon="Groq", tool_calling=True, deprecated=True
+        provider="Groq", name="llama-3.1-70b-versatile", icon="Groq", deprecated=True
     ),
     create_model_metadata(  # Mistral
-        provider="Groq", name="mixtral-8x7b-32768", icon="Groq", tool_calling=True, deprecated=True
+        provider="Groq", name="mixtral-8x7b-32768", icon="Groq", deprecated=True
     ),
-    # Unsupported Models
+    # ===== UNSUPPORTED MODELS =====
+    # Audio/TTS/Guard models that should not appear in LLM model lists
+    # The dynamic system automatically filters these out
     create_model_metadata(  # Mistral
         provider="Groq", name="mistral-saba-24b", icon="Groq", not_supported=True
     ),
@@ -100,6 +104,18 @@ GROQ_MODELS_DETAILED = [
     create_model_metadata(  # Hugging Face
         provider="Groq", name="distil-whisper-large-v3-en", icon="Groq", not_supported=True
     ),
+    create_model_metadata(  # Meta
+        provider="Groq", name="meta-llama/llama-guard-4-12b", icon="Groq", not_supported=True
+    ),
+    create_model_metadata(  # Meta
+        provider="Groq", name="meta-llama/llama-prompt-guard-2-86m", icon="Groq", not_supported=True
+    ),
+    create_model_metadata(  # Meta
+        provider="Groq", name="meta-llama/llama-prompt-guard-2-22m", icon="Groq", not_supported=True
+    ),
+    create_model_metadata(  # OpenAI
+        provider="Groq", name="openai/gpt-oss-safeguard-20b", icon="Groq", not_supported=True
+    ),
 ]
 
 # Generate backwards-compatible lists from the metadata

lfx/base/models/groq_model_discovery.py

@@ -0,0 +1,265 @@
+"""Dynamic Groq model discovery and tool calling detection.
+
+This module fetches available models directly from the Groq API
+and tests their tool calling capabilities programmatically,
+eliminating the need for manual metadata updates.
+"""
+
+import json
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from lfx.log.logger import logger
+
+
+class GroqModelDiscovery:
+    """Discovers and caches Groq model capabilities dynamically."""
+
+    # Cache file location - use local cache directory within models
+    CACHE_FILE = Path(__file__).parent / ".cache" / "groq_models_cache.json"
+    CACHE_DURATION = timedelta(hours=24)  # Refresh cache every 24 hours
+
+    # Models to skip from LLM list (audio, TTS, guards)
+    SKIP_PATTERNS = ["whisper", "tts", "guard", "safeguard", "prompt-guard", "saba"]
+
+    def __init__(self, api_key: str | None = None, base_url: str = "https://api.groq.com"):
+        """Initialize discovery with optional API key for testing.
+
+        Args:
+            api_key: Groq API key. If None, only cached data will be used.
+            base_url: Groq API base URL
+        """
+        self.api_key = api_key
+        self.base_url = base_url
+
+    def get_models(self, *, force_refresh: bool = False) -> dict[str, dict[str, Any]]:
+        """Get available models with their capabilities.
+
+        Args:
+            force_refresh: If True, bypass cache and fetch fresh data
+
+        Returns:
+            Dictionary mapping model IDs to their metadata:
+            {
+                "model-id": {
+                    "name": "model-id",
+                    "provider": "Provider Name",
+                    "tool_calling": True/False,
+                    "preview": True/False,
+                    "not_supported": True/False,  # for non-LLM models
+                    "last_tested": "2025-01-06T10:30:00"
+                }
+            }
+        """
+        # Try to load from cache first
+        if not force_refresh:
+            cached = self._load_cache()
+            if cached:
+                logger.info("Using cached Groq model metadata")
+                return cached
+
+        # Fetch fresh data from API
+        if not self.api_key:
+            logger.warning("No API key provided, using minimal fallback list")
+            return self._get_fallback_models()
+
+        try:
+            models_metadata = {}
+
+            # Step 1: Get list of available models
+            available_models = self._fetch_available_models()
+            logger.info(f"Found {len(available_models)} models from Groq API")
+
+            # Step 2: Categorize models
+            llm_models = []
+            non_llm_models = []
+
+            for model_id in available_models:
+                if any(pattern in model_id.lower() for pattern in self.SKIP_PATTERNS):
+                    non_llm_models.append(model_id)
+                else:
+                    llm_models.append(model_id)
+
+            # Step 3: Test LLM models for tool calling
+            logger.info(f"Testing {len(llm_models)} LLM models for tool calling support...")
+            for model_id in llm_models:
+                supports_tools = self._test_tool_calling(model_id)
+                models_metadata[model_id] = {
+                    "name": model_id,
+                    "provider": self._get_provider_name(model_id),
+                    "tool_calling": supports_tools,
+                    "preview": "preview" in model_id.lower() or "/" in model_id,
+                    "last_tested": datetime.now(timezone.utc).isoformat(),
+                }
+                logger.debug(f"{model_id}: tool_calling={supports_tools}")
+
+            # Step 4: Add non-LLM models as unsupported
+            for model_id in non_llm_models:
+                models_metadata[model_id] = {
+                    "name": model_id,
+                    "provider": self._get_provider_name(model_id),
+                    "not_supported": True,
+                    "last_tested": datetime.now(timezone.utc).isoformat(),
+                }
+
+            # Save to cache
+            self._save_cache(models_metadata)
+
+        except (requests.RequestException, KeyError, ValueError, ImportError) as e:
+            logger.exception(f"Error discovering models: {e}")
+            return self._get_fallback_models()
+        else:
+            return models_metadata
+
+    def _fetch_available_models(self) -> list[str]:
+        """Fetch list of available models from Groq API."""
+        url = f"{self.base_url}/openai/v1/models"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+
+        model_list = response.json()
+        # Use direct access to raise KeyError if 'data' is missing
+        return [model["id"] for model in model_list["data"]]
+
+    def _test_tool_calling(self, model_id: str) -> bool:
+        """Test if a model supports tool calling.
+
+        Args:
+            model_id: The model ID to test
+
+        Returns:
+            True if model supports tool calling, False otherwise
+        """
+        try:
+            import groq
+
+            client = groq.Groq(api_key=self.api_key)
+
+            # Simple tool definition
+            tools = [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "test_tool",
+                        "description": "A test tool",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {"x": {"type": "string"}},
+                            "required": ["x"],
+                        },
+                    },
+                }
+            ]
+
+            messages = [{"role": "user", "content": "test"}]
+
+            # Try to make a request with tools
+            client.chat.completions.create(
+                model=model_id, messages=messages, tools=tools, tool_choice="auto", max_tokens=10
+            )
+
+        except (ImportError, AttributeError, TypeError, ValueError, RuntimeError, KeyError) as e:
+            error_msg = str(e).lower()
+            # If error mentions tool calling, model doesn't support it
+            if "tool" in error_msg:
+                return False
+            # Other errors might be rate limits, etc - be conservative
+            logger.warning(f"Error testing {model_id}: {e}")
+            return False
+        else:
+            return True
+
+    def _get_provider_name(self, model_id: str) -> str:
+        """Extract provider name from model ID."""
+        if "/" in model_id:
+            provider_map = {
+                "meta-llama": "Meta",
+                "openai": "OpenAI",
+                "groq": "Groq",
+                "moonshotai": "Moonshot AI",
+                "qwen": "Alibaba Cloud",
+            }
+            prefix = model_id.split("/")[0]
+            return provider_map.get(prefix, prefix.title())
+
+        # Common patterns
+        if model_id.startswith("llama"):
+            return "Meta"
+        if model_id.startswith("qwen"):
+            return "Alibaba Cloud"
+        if model_id.startswith("allam"):
+            return "SDAIA"
+
+        return "Groq"
+
+    def _load_cache(self) -> dict[str, dict] | None:
+        """Load cached model metadata if it exists and is fresh."""
+        if not self.CACHE_FILE.exists():
+            return None
+
+        try:
+            with self.CACHE_FILE.open() as f:
+                cache_data = json.load(f)
+
+            # Check cache age
+            cache_time = datetime.fromisoformat(cache_data["cached_at"])
+            if datetime.now(timezone.utc) - cache_time > self.CACHE_DURATION:
+                logger.info("Cache expired, will fetch fresh data")
+                return None
+
+            return cache_data["models"]
+
+        except (json.JSONDecodeError, KeyError, ValueError) as e:
+            logger.warning(f"Invalid cache file: {e}")
+            return None
+
+    def _save_cache(self, models_metadata: dict[str, dict]) -> None:
+        """Save model metadata to cache."""
+        try:
+            cache_data = {"cached_at": datetime.now(timezone.utc).isoformat(), "models": models_metadata}
+
+            self.CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+            with self.CACHE_FILE.open("w") as f:
+                json.dump(cache_data, f, indent=2)
+
+            logger.info(f"Cached {len(models_metadata)} models to {self.CACHE_FILE}")
+
+        except (OSError, TypeError, ValueError) as e:
+            logger.warning(f"Failed to save cache: {e}")
+
+    def _get_fallback_models(self) -> dict[str, dict]:
+        """Return minimal fallback list when API is unavailable."""
+        return {
+            "llama-3.1-8b-instant": {
+                "name": "llama-3.1-8b-instant",
+                "provider": "Meta",
+                "tool_calling": True,
+                "preview": False,
+            },
+            "llama-3.3-70b-versatile": {
+                "name": "llama-3.3-70b-versatile",
+                "provider": "Meta",
+                "tool_calling": True,
+                "preview": False,
+            },
+        }
+
+
+# Convenience function for use in other modules
+def get_groq_models(api_key: str | None = None, *, force_refresh: bool = False) -> dict[str, dict]:
+    """Get Groq models with their capabilities.
+
+    Args:
+        api_key: Optional API key for testing. If None, uses cached data.
+        force_refresh: If True, bypass cache and fetch fresh data.
+
+    Returns:
+        Dictionary of model metadata
+    """
+    discovery = GroqModelDiscovery(api_key=api_key)
+    return discovery.get_models(force_refresh=force_refresh)

lfx/base/models/model.py

@@ -296,7 +296,7 @@ class LCModelComponent(Component):
             )
             model_message.properties.source = self._build_source(self._id, self.display_name, self)
             lf_message = await self.send_message(model_message)
-            result = lf_message.text
+            result = lf_message.text or ""
         else:
             message = await runnable.ainvoke(inputs)
             result = message.content if hasattr(message, "content") else message

lfx/base/models/model_utils.py

@@ -1,3 +1,14 @@
+import asyncio
+from urllib.parse import urljoin
+
+import httpx
+
+from lfx.log.logger import logger
+from lfx.utils.util import transform_localhost_url
+
+HTTP_STATUS_OK = 200
+
+
 def get_model_name(llm, display_name: str | None = "Custom"):
     attributes_to_check = ["model_name", "model", "model_id", "deployment_name"]
 
@@ -6,3 +17,92 @@ def get_model_name(llm, display_name: str | None = "Custom"):
 
     # If no matching attribute is found, return the class name as a fallback
     return model_name if model_name is not None else display_name
+
+
+async def is_valid_ollama_url(url: str) -> bool:
+    """Check if the provided URL is a valid Ollama API endpoint."""
+    try:
+        url = transform_localhost_url(url)
+        if not url:
+            return False
+        # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+        url = url.rstrip("/").removesuffix("/v1")
+        if not url.endswith("/"):
+            url = url + "/"
+        async with httpx.AsyncClient() as client:
+            return (await client.get(url=urljoin(url, "api/tags"))).status_code == HTTP_STATUS_OK
+    except httpx.RequestError:
+        logger.debug(f"Invalid Ollama URL: {url}")
+        return False
+
+
+async def get_ollama_models(
+    base_url_value: str, desired_capability: str, json_models_key: str, json_name_key: str, json_capabilities_key: str
+) -> list[str]:
+    """Fetch available completion models from the Ollama API.
+
+    Filters out embedding models and only returns models with completion capability.
+
+    Args:
+        base_url_value (str): The base URL of the Ollama API.
+        desired_capability (str): The desired capability of the model.
+        json_models_key (str): The key in the JSON response that contains the models.
+        json_name_key (str): The key in the JSON response that contains the model names.
+        json_capabilities_key (str): The key in the JSON response that contains the model capabilities.
+
+    Returns:
+        list[str]: A sorted list of model names that support completion.
+
+    Raises:
+        ValueError: If there is an issue with the API request or response.
+    """
+    try:
+        # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+        base_url = base_url_value.rstrip("/").removesuffix("/v1")
+        if not base_url.endswith("/"):
+            base_url = base_url + "/"
+        base_url = transform_localhost_url(base_url)
+
+        # Ollama REST API to return models
+        tags_url = urljoin(base_url, "api/tags")
+
+        # Ollama REST API to return model capabilities
+        show_url = urljoin(base_url, "api/show")
+        tags_response = None
+
+        async with httpx.AsyncClient() as client:
+            # Fetch available models
+            tags_response = await client.get(url=tags_url)
+            tags_response.raise_for_status()
+            models = tags_response.json()
+            if asyncio.iscoroutine(models):
+                models = await models
+            await logger.adebug(f"Available models: {models}")
+
+            # Filter models that are NOT embedding models
+            model_ids = []
+            for model in models.get(json_models_key, []):
+                model_name = model.get(json_name_key)
+                if not model_name:
+                    continue
+                await logger.adebug(f"Checking model: {model_name}")
+
+                payload = {"model": model_name}
+                show_response = await client.post(url=show_url, json=payload)
+                show_response.raise_for_status()
+                json_data = show_response.json()
+                if asyncio.iscoroutine(json_data):
+                    json_data = await json_data
+
+                capabilities = json_data.get(json_capabilities_key, [])
+                await logger.adebug(f"Model: {model_name}, Capabilities: {capabilities}")
+
+                if desired_capability in capabilities:
+                    model_ids.append(model_name)
+
+            return sorted(model_ids)
+
+    except (httpx.RequestError, ValueError) as e:
+        msg = "Could not get model names from Ollama."
+        await logger.aexception(msg)
+        raise ValueError(msg) from e