feat: enhance provider detection and model resolution in Agent class

Author: Iamsdt

.gitignore

@@ -84,3 +84,5 @@ site
 
 graphify-out/
 service_account.json
+
+eval_reports/

agentflow/core/graph/agent.py

@@ -264,27 +264,24 @@ class MyState(AgentState):
             **kwargs,
         )
 
-        # check user sending model and provider as prefix, if provider is not explicitly provided
-        if "/" in model and provider is None:
-            provider, model = model.split("/", 1)
-            self.model = model
-
         # Store output type
         self.output_type = output_type.lower()
         self.output_schema = output_schema
         self._validate_output_schema_output_type()
 
         # Determine provider; self.llm_kwargs is set by super().__init__ and is
         # already available here for _create_client().
+        self.base_url = base_url
         if provider is not None:
+            # Provider explicitly supplied — trust it as-is.
             self.provider = provider.lower()
-            self.base_url = base_url
             self.client = self._create_client(self.provider, base_url, use_vertex_ai)
         else:
-            # Auto-detect provider from model name
-            self.provider = self._detect_provider_from_model(model, use_vertex_ai)
-            self.base_url = base_url
-            self.client = self._create_client(self.provider, base_url)
+            # Resolve provider (and strip a recognised ``provider/`` prefix) from
+            # the model string. Unknown prefixes resolve to ``openai`` and keep
+            # the full model name (e.g. OpenAI-compatible/self-hosted models).
+            self.provider, self.model = self._resolve_provider_and_model(model, use_vertex_ai)
+            self.client = self._create_client(self.provider, base_url, use_vertex_ai)
 
         # Validate that provider supports the output type
         self._validate_output_type()

agentflow/core/graph/agent_internal/providers.py

@@ -5,7 +5,11 @@
 import logging
 from typing import Any, Protocol
 
-from agentflow.core.llm.client_factory import create_llm_client, detect_provider
+from agentflow.core.llm.client_factory import (
+    create_llm_client,
+    detect_provider,
+    resolve_provider_and_model,
+)
 
 from .constants import (
     CLIENT_CONSTRUCTOR_KWARGS,
@@ -53,6 +57,18 @@ def _detect_provider_from_model(self, model: str, use_vertex_ai: bool = False) -
         """Infer the provider from the model name when not explicitly supplied."""
         return detect_provider(model, use_vertex_ai=use_vertex_ai)
 
+    def _resolve_provider_and_model(
+        self, model: str, use_vertex_ai: bool = False
+    ) -> tuple[str, str]:
+        """Resolve a model string into a ``(provider, model)`` pair.
+
+        Recognised ``provider/`` prefixes (``gemini``, ``google``, ``openai``,
+        ``gpt``) select the provider and are stripped from the model name.
+        Unknown prefixes are kept intact and resolve to the ``openai`` provider
+        so OpenAI-compatible / self-hosted models work out of the box.
+        """
+        return resolve_provider_and_model(model, use_vertex_ai=use_vertex_ai)
+
     def _create_google_vertex_ai_client(self) -> Any:
         return create_llm_client("google", use_vertex_ai=True)
 

agentflow/core/llm/client_factory.py

@@ -14,6 +14,16 @@
 
 logger = logging.getLogger("agentflow.llm")
 
+# Recognised ``provider/`` prefixes mapped to the concrete provider the client
+# factory can build. Anything not listed here is an unknown prefix and resolves
+# to ``"openai"`` (the OpenAI SDK is used for OpenAI-compatible endpoints).
+_PROVIDER_PREFIXES = {
+    "gemini": "google",
+    "google": "google",
+    "openai": "openai",
+    "gpt": "openai",
+}
+
 # Keys allowed in the AsyncOpenAI constructor but NOT in per-request calls.
 _CLIENT_CONSTRUCTOR_KWARGS = frozenset(
     {
@@ -44,10 +54,8 @@ def detect_provider(model: str, use_vertex_ai: bool = False) -> str:
 
     if "/" in model:
         prefix = model.split("/", 1)[0].lower()
-        if prefix in ("gemini", "google"):
-            return "google"
-        if prefix in ("openai", "gpt"):
-            return "openai"
+        if prefix in _PROVIDER_PREFIXES:
+            return _PROVIDER_PREFIXES[prefix]
         # Unknown prefix — fall through to name-based detection using the suffix
         model = model.split("/", 1)[1]
 
@@ -64,6 +72,35 @@ def detect_provider(model: str, use_vertex_ai: bool = False) -> str:
     return "openai"
 
 
+def resolve_provider_and_model(
+    model: str, use_vertex_ai: bool = False
+) -> tuple[str, str]:
+    """Resolve a model string into a concrete ``(provider, model)`` pair.
+
+    Unlike :func:`detect_provider`, this also returns the model name that should
+    be sent to the provider. A *recognised* ``provider/`` prefix (e.g.
+    ``"gemini/..."``, ``"openai/..."``) is stripped, since the provider is
+    selected from the prefix. An *unrecognised* prefix is kept intact: it may be
+    an OpenAI-compatible / HuggingFace-style identifier (e.g.
+    ``"meta-llama/Llama-3-70b"``) where the slash is part of the real model name.
+    Such models always resolve to the ``"openai"`` provider.
+
+    Args:
+        model: Model identifier, optionally prefixed with ``"provider/"``.
+        use_vertex_ai: When True, always selects the ``"google"`` provider.
+
+    Returns:
+        A ``(provider, model)`` tuple where provider is ``"google"`` or
+        ``"openai"``.
+    """
+    if "/" in model:
+        prefix, rest = model.split("/", 1)
+        if prefix.lower() in _PROVIDER_PREFIXES:
+            return detect_provider(model, use_vertex_ai=use_vertex_ai), rest
+
+    return detect_provider(model, use_vertex_ai=use_vertex_ai), model
+
+
 def create_llm_client(
     provider: str,
     *,

tests/graph/test_agent_internal.py

@@ -281,6 +281,56 @@ def test_deepseek_defaults_to_openai(self):
         agent = _make_openai_agent()
         assert agent._detect_provider_from_model("deepseek-chat") == "openai"
 
+    def test_unknown_prefix_falls_back_to_openai(self):
+        agent = _make_openai_agent()
+        assert agent._detect_provider_from_model("ollama/llama3") == "openai"
+        assert agent._detect_provider_from_model("anthropic/claude-3") == "openai"
+
+
+class TestResolveProviderAndModel:
+    """``_resolve_provider_and_model`` returns ``(provider, model)``: it strips
+    recognised provider aliases and defaults unknown prefixes to openai."""
+
+    def test_gemini_alias_maps_to_google(self):
+        agent = _make_openai_agent()
+        assert agent._resolve_provider_and_model("gemini/gemini-2.5-flash") == (
+            "google",
+            "gemini-2.5-flash",
+        )
+
+    def test_google_alias_maps_to_google(self):
+        agent = _make_openai_agent()
+        assert agent._resolve_provider_and_model("google/gemini-2.0-flash") == (
+            "google",
+            "gemini-2.0-flash",
+        )
+
+    def test_openai_alias_maps_to_openai(self):
+        agent = _make_openai_agent()
+        assert agent._resolve_provider_and_model("openai/gpt-4o") == ("openai", "gpt-4o")
+
+    def test_gpt_alias_maps_to_openai(self):
+        agent = _make_openai_agent()
+        assert agent._resolve_provider_and_model("gpt/gpt-4o") == ("openai", "gpt-4o")
+
+    def test_unknown_prefix_defaults_to_openai_and_keeps_full_model(self):
+        agent = _make_openai_agent()
+        assert agent._resolve_provider_and_model("meta-llama/Llama-3-70b") == (
+            "openai",
+            "meta-llama/Llama-3-70b",
+        )
+
+    def test_bare_unknown_model_defaults_to_openai(self):
+        agent = _make_openai_agent()
+        assert agent._resolve_provider_and_model("llama3:70b") == ("openai", "llama3:70b")
+
+    def test_use_vertex_ai_forces_google(self):
+        agent = _make_openai_agent()
+        assert agent._resolve_provider_and_model("llama3:70b", use_vertex_ai=True) == (
+            "google",
+            "llama3:70b",
+        )
+
 
 class TestValidateOutputType:
     def test_valid_text_type_does_not_raise(self):
@@ -1955,6 +2005,41 @@ def test_unknown_model_without_provider_auto_detects_openai(self):
             agent = Agent(model="llama3:70b", reasoning_config=None)
         assert agent.provider == "openai"
 
+    def test_gemini_slash_prefix_maps_to_google_provider(self):
+        """The ``gemini/`` alias must resolve to the ``google`` provider."""
+        with patch.object(Agent, "_create_client", return_value=MagicMock()):
+            agent = Agent(model="gemini/gemini-2.5-flash", reasoning_config=None)
+        assert agent.provider == "google"
+        assert agent.model == "gemini-2.5-flash"
+
+    def test_gpt_slash_prefix_maps_to_openai_provider(self):
+        """The ``gpt/`` alias must resolve to the ``openai`` provider."""
+        with patch.object(Agent, "_create_client", return_value=MagicMock()):
+            agent = Agent(model="gpt/gpt-4o", reasoning_config=None)
+        assert agent.provider == "openai"
+        assert agent.model == "gpt-4o"
+
+    def test_unknown_prefix_resolves_to_openai_and_keeps_full_model(self):
+        """An unrecognised prefix must default to openai, not google, and keep
+        the full model string (it may be an OpenAI-compatible / HF-style name)."""
+        with patch.object(Agent, "_create_client", return_value=MagicMock()):
+            agent = Agent(model="meta-llama/Llama-3-70b", reasoning_config=None)
+        assert agent.provider == "openai"
+        assert agent.model == "meta-llama/Llama-3-70b"
+
+    def test_anthropic_prefix_resolves_to_openai(self):
+        """Claude via an OpenAI-compatible endpoint should not select google."""
+        with patch.object(Agent, "_create_client", return_value=MagicMock()):
+            agent = Agent(model="anthropic/claude-3", reasoning_config=None)
+        assert agent.provider == "openai"
+        assert agent.model == "anthropic/claude-3"
+
+    def test_ollama_prefix_resolves_to_openai(self):
+        with patch.object(Agent, "_create_client", return_value=MagicMock()):
+            agent = Agent(model="ollama/llama3", reasoning_config=None)
+        assert agent.provider == "openai"
+        assert agent.model == "ollama/llama3"
+
     # ── reasoning config normalization ────────────────────────────────────
 
     def test_default_sentinel_produces_medium_effort(self):