Skip to content

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.

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.py
index 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 functools
import os
from abc import ABC, abstractmethod
from dataclasses import dataclass
@@ -30,7 +31,7 @@ from marimo._plugins.ui._impl.chat.chat import (
)
from marimo._server.ai.config import AnyProviderConfig
from marimo._server.ai.constants import ANTHROPIC_DEFAULT_MAX_TOKENS
-from marimo._server.ai.ids import AiModelId
+from marimo._server.ai.ids import AiModelId, AiProviderId
from marimo._server.ai.tools.tool_manager import get_tool_manager
from marimo._server.ai.tools.types import ToolDefinition
from 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_class
from 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-compatible
LOGGER.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.py
index 20722d8383..d7e238a9c7 100644
--- a/tests/_server/ai/test_providers.py
+++ b/tests/_server/ai/test_providers.py
@@ -8,6 +8,7 @@ import pytest
from marimo._config.config import AiConfig
from marimo._dependencies.dependencies import Dependency, DependencyManager
from marimo._server.ai.config import AnyProviderConfig
+from marimo._server.ai.ids import AiModelId
from 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"