A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
fix(ai): infer provider profile from base_url for custom providers (#9813)
Shahmir Varqha76a0d3c88f7f
diff --git a/marimo/_server/ai/providers.py b/marimo/_server/ai/providers.pyindex cf3be6827a..3fd9bab042 100644--- a/marimo/_server/ai/providers.py+++ b/marimo/_server/ai/providers.py@@ -1,6 +1,7 @@# Copyright 2026 Marimo. All rights reserved.from __future__ import annotations+import functoolsimport osfrom abc import ABC, abstractmethodfrom dataclasses import dataclass@@ -30,7 +31,7 @@ from marimo._plugins.ui._impl.chat.chat import ()from marimo._server.ai.config import AnyProviderConfigfrom marimo._server.ai.constants import ANTHROPIC_DEFAULT_MAX_TOKENS-from marimo._server.ai.ids import AiModelId+from marimo._server.ai.ids import AiModelId, AiProviderIdfrom marimo._server.ai.tools.tool_manager import get_tool_managerfrom marimo._server.ai.tools.types import ToolDefinitionfrom marimo._server.models.completion import UIMessage as ServerUIMessage@@ -506,6 +507,86 @@ class AzureOpenAIProvider(OpenAIProvider):)+def _normalize_base_url(base_url: str | None) -> str | None:+ """Normalize a base URL for cross-provider comparison.++ Strips the scheme, a trailing `/v1` path segment, and trailing slashes so+ that e.g. `https://api.provider.com` and `https://api.provider.com/v1/`+ compare equal.+ """+ if not base_url:+ return None+ normalized = base_url.strip().lower()+ normalized = normalized.removeprefix("https://").removeprefix("http://")+ normalized = normalized.rstrip("/").removesuffix("/v1")+ return normalized.rstrip("/") or None+++def _try_infer_provider_class(+ provider_name: str,+) -> type[Provider[Any]] | None:+ """Resolve a pydantic-ai provider class by name, or `None` if unknown."""+ from pydantic_ai.providers import infer_provider_class++ try:+ return infer_provider_class(provider_name)+ except ValueError:+ return None++[email protected]_cache(maxsize=1)+def _openai_compatible_provider_names() -> tuple[+ frozenset[str], frozenset[str]+]:+ """(responses-compatible, chat-compatible) provider names from pydantic-ai."""+ from pydantic_ai.models import (+ OpenAIChatCompatibleProvider,+ OpenAIResponsesCompatibleProvider,+ )++ # TypeAliasType objects; `.__value__` exposes the underlying Literal.+ return (+ frozenset(get_args(OpenAIResponsesCompatibleProvider.__value__)),+ frozenset(get_args(OpenAIChatCompatibleProvider.__value__)),+ )++[email protected]_cache(maxsize=1)+def _known_provider_base_urls() -> dict[str, str]:+ """Map normalized base URLs to pydantic-ai provider names.++ Discovered from pydantic-ai's OpenAI-compatible providers so that a custom+ provider whose *name* we don't recognize, but whose *base URL* points at a+ known service (e.g. `https://api.deepseek.com`) points to the correct provider.+ """+ responses, chat = _openai_compatible_provider_names()+ mapping: dict[str, str] = {}+ # Sorted so that, if two providers normalize alike, the first wins.+ for name in sorted(responses | chat):+ provider_class = _try_infer_provider_class(name)+ if provider_class is None:+ continue+ try:+ base_url = object.__new__(provider_class).base_url+ except Exception as e:+ LOGGER.debug(+ f"Skipping provider '{name}' during base URL discovery: {e}"+ )+ continue+ normalized = _normalize_base_url(base_url)+ if normalized:+ mapping.setdefault(normalized, name)+ return mapping+++def _infer_provider_name_from_base_url(base_url: str | None) -> str | None:+ """Resolve a known pydantic-ai provider name from a base URL, if any."""+ normalized = _normalize_base_url(base_url)+ if not normalized:+ return None+ return _known_provider_base_urls().get(normalized)++class CustomProvider(OpenAIClientMixin, PydanticProvider["Provider[Any]"]):"""Support for custom providers which may or may not be OpenAI-compatible.@@ -522,29 +603,19 @@ class CustomProvider(OpenAIClientMixin, PydanticProvider["Provider[Any]"]):deps: list[Dependency] | None = None,):self._provider_name = model_id.provider+ if _try_infer_provider_class(self._provider_name) is None:+ matched = _infer_provider_name_from_base_url(config.base_url)+ if matched is not None:+ LOGGER.debug(+ f"Custom provider '{self._provider_name}' matched known "+ f"provider '{matched}' by base URL; using its profile."+ )+ self._provider_name = AiProviderId(matched)self._responses_compatible, self._chat_compatible = (- self._get_openai_compatible_providers()+ _openai_compatible_provider_names())super().__init__(model_id.model, config, deps)- def _get_openai_compatible_providers(self) -> tuple[set[str], set[str]]:- """Get the sets of OpenAI-compatible providers from pydantic_ai.-- Returns:- Tuple of (responses_compatible, chat_compatible) provider names.- """- from pydantic_ai.models import (- OpenAIChatCompatibleProvider,- OpenAIResponsesCompatibleProvider,- )-- # These are TypeAliasType objects, so we need .__value__ to get the Literal- responses_compatible = set(- get_args(OpenAIResponsesCompatibleProvider.__value__)- )- chat_compatible = set(get_args(OpenAIChatCompatibleProvider.__value__))- return responses_compatible, chat_compatible-def _is_openai_compatible(self) -> bool:"""Check if the provider uses an OpenAI-compatible API."""provider = self._provider_name.lower()@@ -567,16 +638,13 @@ class CustomProvider(OpenAIClientMixin, PydanticProvider["Provider[Any]"]):Reference: https://ai.pydantic.dev/models/openai/#openai-compatible-models"""- from pydantic_ai.providers import infer_provider_classfrom pydantic_ai.providers.openai import (OpenAIProvider as PydanticOpenAI,)# Try to infer the provider class- try:- provider_class = infer_provider_class(self._provider_name)- LOGGER.debug(f"Inferred provider class: {provider_class.__name__}")- except ValueError:+ provider_class = _try_infer_provider_class(self._provider_name)+ if provider_class is None:# Unknown provider, fall back to OpenAI-compatibleLOGGER.debug(f"Unknown provider: {self._provider_name}. Falling back to OpenAIProvider."@@ -584,6 +652,8 @@ class CustomProvider(OpenAIClientMixin, PydanticProvider["Provider[Any]"]):client = self.get_openai_client(config)return PydanticOpenAI(openai_client=client)+ LOGGER.debug(f"Inferred provider class: {provider_class.__name__}")+if self._is_openai_compatible():client = self.get_openai_client(config)try:diff --git a/tests/_server/ai/test_providers.py b/tests/_server/ai/test_providers.pyindex 20722d8383..d7e238a9c7 100644--- a/tests/_server/ai/test_providers.py+++ b/tests/_server/ai/test_providers.py@@ -8,6 +8,7 @@ import pytestfrom marimo._config.config import AiConfigfrom marimo._dependencies.dependencies import Dependency, DependencyManagerfrom marimo._server.ai.config import AnyProviderConfig+from marimo._server.ai.ids import AiModelIdfrom marimo._server.ai.providers import (AnthropicProvider,AzureOpenAIProvider,@@ -15,6 +16,8 @@ from marimo._server.ai.providers import (CustomProvider,GoogleProvider,OpenAIProvider,+ _infer_provider_name_from_base_url,+ _normalize_base_url,get_completion_provider,)@@ -528,3 +531,138 @@ def test_custom_provider_agent_omits_max_tokens_when_none() -> None:max_tokens=None, tools=[], system_prompt="x")assert "max_tokens" not in dict(agent.model_settings or {})+++ ("base_url", "expected"),+ [+ pytest.param(None, None, id="none"),+ pytest.param("", None, id="empty"),+ pytest.param(+ "https://api.deepseek.com", "api.deepseek.com", id="https"+ ),+ pytest.param(+ "http://api.deepseek.com/", "api.deepseek.com", id="http_trailing"+ ),+ pytest.param(+ "https://api.deepseek.com/v1/",+ "api.deepseek.com",+ id="strip_v1",+ ),+ pytest.param(+ " https://API.DeepSeek.com/v1 ",+ "api.deepseek.com",+ id="whitespace_and_case",+ ),+ pytest.param(+ "https://openrouter.ai/api/v1",+ "openrouter.ai/api",+ id="path_before_v1",+ ),+ pytest.param(+ "https://models.github.ai/inference",+ "models.github.ai/inference",+ id="path_without_v1",+ ),+ pytest.param(+ "https://api.x.ai/V1",+ "api.x.ai",+ id="uppercase_v1_suffix",+ ),+ pytest.param(+ "https://generativelanguage.googleapis.com/v1beta",+ "generativelanguage.googleapis.com/v1beta",+ id="v1beta_not_stripped",+ ),+ ],+)+def test_normalize_base_url(+ base_url: str | None, expected: str | None+) -> None:+ assert _normalize_base_url(base_url) == expected++[email protected]("pydantic_ai")+ ("base_url", "expected"),+ [+ pytest.param("https://api.deepseek.com", "deepseek", id="deepseek"),+ pytest.param(+ "https://api.deepseek.com/v1/", "deepseek", id="deepseek_v1"+ ),+ pytest.param(+ "https://api.moonshot.ai/v1", "moonshotai", id="moonshot"+ ),+ pytest.param(+ "https://openrouter.ai/api/v1/", "openrouter", id="openrouter"+ ),+ # Hosts not discovered from pydantic-ai's providers -> no match, so we+ # fall back to the generic OpenAI provider (preserving prior behavior).+ # `api.openai.com` is LiteLLM's client-derived default, which we skip.+ pytest.param("https://my.internal.llm/v1", None, id="unknown_host"),+ pytest.param("https://api.openai.com/v1", None, id="openai_host"),+ pytest.param(None, None, id="no_base_url"),+ ],+)+def test_infer_provider_name_from_base_url(+ base_url: str | None, expected: str | None+) -> None:+ assert _infer_provider_name_from_base_url(base_url) == expected++[email protected]("pydantic_ai")+def test_custom_provider_inherits_profile_from_base_url() -> None:+ """A custom provider whose name we don't recognize, but whose base URL+ points at DeepSeek, inherits DeepSeek's profile so `reasoning_content`+ round-trips. Regression test for #9786."""+ from pydantic_ai.profiles.openai import OpenAIModelProfile++ config = AnyProviderConfig(+ api_key="test-key", base_url="https://api.deepseek.com"+ )+ provider = CustomProvider(+ AiModelId.from_model("deepseek_official/deepseek-v4-flash"), config+ )++ # The unknown name was resolved to the known `deepseek` provider.+ assert provider._provider_name == "deepseek"+ assert provider.provider.name == "deepseek"++ model = provider.create_model(max_tokens=None)+ profile = OpenAIModelProfile.from_profile(model.profile)+ assert profile.openai_chat_thinking_field == "reasoning_content"+ assert profile.openai_chat_send_back_thinking_parts == "field"++[email protected]("pydantic_ai")+def test_custom_provider_unknown_base_url_stays_generic() -> None:+ """An unknown name with an unrecognized base URL falls back to the generic+ OpenAI provider (no thinking field), preserving prior behavior."""+ from pydantic_ai.profiles.openai import OpenAIModelProfile++ config = AnyProviderConfig(+ api_key="test-key", base_url="https://my.internal.llm/v1"+ )+ provider = CustomProvider(+ AiModelId.from_model("my_provider/my-model"), config+ )++ assert provider._provider_name == "my_provider"+ assert provider.provider.name == "openai"++ model = provider.create_model(max_tokens=None)+ profile = OpenAIModelProfile.from_profile(model.profile)+ assert profile.openai_chat_thinking_field is None++[email protected]("pydantic_ai")+def test_custom_provider_known_name_not_overridden_by_base_url() -> None:+ """A recognized provider name is used as-is; the base URL never overrides+ it (so e.g. an OpenRouter config pointed at DeepSeek keeps OpenRouter)."""+ config = AnyProviderConfig(+ api_key="test-key", base_url="https://api.deepseek.com"+ )+ provider = CustomProvider(+ AiModelId.from_model("openrouter/some-model"), config+ )+ assert provider._provider_name == "openrouter"