Using model_name and system model properties (#865)

Author: sydney-runkle

docs/models.md

@@ -377,7 +377,7 @@ pip/uv-add 'pydantic-ai-slim[mistral]'
 
 To use [Mistral](https://mistral.ai) through their API, go to [console.mistral.ai/api-keys/](https://console.mistral.ai/api-keys/) and follow your nose until you find the place to generate an API key.
 
-[`NamedMistralModels`][pydantic_ai.models.mistral.NamedMistralModels] contains a list of the most popular Mistral models.
+[`MistralModelName`][pydantic_ai.models.mistral.MistralModelName] contains a list of the most popular Mistral models.
 
 ### Environment variable
 
@@ -434,7 +434,7 @@ pip/uv-add 'pydantic-ai-slim[cohere]'
 
 To use [Cohere](https://cohere.com/) through their API, go to [dashboard.cohere.com/api-keys](https://dashboard.cohere.com/api-keys) and follow your nose until you find the place to generate an API key.
 
-[`NamedCohereModels`][pydantic_ai.models.cohere.NamedCohereModels] contains a list of the most popular Cohere models.
+[`CohereModelName`][pydantic_ai.models.cohere.CohereModelName] contains a list of the most popular Cohere models.
 
 ### Environment variable
 

pydantic_ai_slim/pydantic_ai/agent.py

@@ -309,7 +309,7 @@ async def main():
             '{agent_name} run {prompt=}',
             prompt=user_prompt,
             agent=self,
-            model_name=model_used.name() if model_used else 'no-model',
+            model_name=model_used.model_name if model_used else 'no-model',
             agent_name=self.name or 'agent',
         ) as run_span:
             # Build the deps object for the graph
@@ -554,7 +554,7 @@ async def main():
             '{agent_name} run stream {prompt=}',
             prompt=user_prompt,
             agent=self,
-            model_name=model_used.name(),
+            model_name=model_used.model_name if model_used else 'no-model',
             agent_name=self.name or 'agent',
         ) as run_span:
             # Build the deps object for the graph

pydantic_ai_slim/pydantic_ai/models/__init__.py

@@ -173,9 +173,8 @@ class ModelRequestParameters:
 class Model(ABC):
     """Abstract class for a model."""
 
-    @abstractmethod
-    def name(self) -> str:
-        raise NotImplementedError()
+    _model_name: str
+    _system: str | None
 
     @abstractmethod
     async def request(
@@ -201,6 +200,16 @@ async def request_stream(
         # noinspection PyUnreachableCode
         yield  # pragma: no cover
 
+    @property
+    def model_name(self) -> str:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider, ex: openai."""
+        return self._system
+
 
 @dataclass
 class StreamedResponse(ABC):
@@ -311,26 +320,26 @@ def infer_model(model: Model | KnownModelName) -> Model:
     elif model.startswith('google-gla'):
         from .gemini import GeminiModel
 
-        return GeminiModel(model[11:])  # pyright: ignore[reportArgumentType]
+        return GeminiModel(model[11:])
     # backwards compatibility with old model names (ex, gemini-1.5-flash -> google-gla:gemini-1.5-flash)
     elif model.startswith('gemini'):
         from .gemini import GeminiModel
 
         # noinspection PyTypeChecker
-        return GeminiModel(model)  # pyright: ignore[reportArgumentType]
+        return GeminiModel(model)
     elif model.startswith('groq:'):
         from .groq import GroqModel
 
-        return GroqModel(model[5:])  # pyright: ignore[reportArgumentType]
+        return GroqModel(model[5:])
     elif model.startswith('google-vertex'):
         from .vertexai import VertexAIModel
 
-        return VertexAIModel(model[14:])  # pyright: ignore[reportArgumentType]
+        return VertexAIModel(model[14:])
     # backwards compatibility with old model names (ex, vertexai:gemini-1.5-flash -> google-vertex:gemini-1.5-flash)
     elif model.startswith('vertexai:'):
         from .vertexai import VertexAIModel
 
-        return VertexAIModel(model[9:])  # pyright: ignore[reportArgumentType]
+        return VertexAIModel(model[9:])
     elif model.startswith('mistral:'):
         from .mistral import MistralModel
 

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -68,14 +68,14 @@
     'claude-3-5-sonnet-latest',
     'claude-3-opus-latest',
 ]
-"""Latest named Anthropic models."""
+"""Latest Anthropic models."""
 
 AnthropicModelName = Union[str, LatestAnthropicModelNames]
 """Possible Anthropic model names.
 
 Since Anthropic supports a variety of date-stamped models, we explicitly list the latest models but
 allow any name in the type hints.
-Since [the Anthropic docs](https://docs.anthropic.com/en/docs/about-claude/models) for a full list.
+See [the Anthropic docs](https://docs.anthropic.com/en/docs/about-claude/models) for a full list.
 """
 
 
@@ -101,9 +101,11 @@ class AnthropicModel(Model):
         We anticipate adding support for streaming responses in a near-term future release.
     """
 
-    model_name: AnthropicModelName
     client: AsyncAnthropic = field(repr=False)
 
+    _model_name: AnthropicModelName = field(repr=False)
+    _system: str | None = field(default='anthropic', repr=False)
+
     def __init__(
         self,
         model_name: AnthropicModelName,
@@ -124,7 +126,7 @@ def __init__(
                 client to use, if provided, `api_key` and `http_client` must be `None`.
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
-        self.model_name = model_name
+        self._model_name = model_name
         if anthropic_client is not None:
             assert http_client is None, 'Cannot provide both `anthropic_client` and `http_client`'
             assert api_key is None, 'Cannot provide both `anthropic_client` and `api_key`'
@@ -134,9 +136,6 @@ def __init__(
         else:
             self.client = AsyncAnthropic(api_key=api_key, http_client=cached_async_http_client())
 
-    def name(self) -> str:
-        return f'anthropic:{self.model_name}'
-
     async def request(
         self,
         messages: list[ModelMessage],
@@ -211,7 +210,7 @@ async def _messages_create(
             max_tokens=model_settings.get('max_tokens', 1024),
             system=system_prompt or NOT_GIVEN,
             messages=anthropic_messages,
-            model=self.model_name,
+            model=self._model_name,
             tools=tools or NOT_GIVEN,
             tool_choice=tool_choice or NOT_GIVEN,
             stream=stream,
@@ -237,7 +236,7 @@ def _process_response(self, response: AnthropicMessage) -> ModelResponse:
                     )
                 )
 
-        return ModelResponse(items, model_name=self.model_name)
+        return ModelResponse(items, model_name=self._model_name)
 
     async def _process_streamed_response(self, response: AsyncStream[RawMessageStreamEvent]) -> StreamedResponse:
         peekable_response = _utils.PeekableAsyncStream(response)
@@ -247,7 +246,9 @@ async def _process_streamed_response(self, response: AsyncStream[RawMessageStrea
 
         # Since Anthropic doesn't provide a timestamp in the message, we'll use the current time
         timestamp = datetime.now(tz=timezone.utc)
-        return AnthropicStreamedResponse(_model_name=self.model_name, _response=peekable_response, _timestamp=timestamp)
+        return AnthropicStreamedResponse(
+            _model_name=self._model_name, _response=peekable_response, _timestamp=timestamp
+        )
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[ToolParam]:
         tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]

pydantic_ai_slim/pydantic_ai/models/cohere.py

@@ -52,7 +52,7 @@
         "you can use the `cohere` optional group — `pip install 'pydantic-ai-slim[cohere]'`"
     ) from _import_error
 
-NamedCohereModels = Literal[
+LatestCohereModelNames = Literal[
     'c4ai-aya-expanse-32b',
     'c4ai-aya-expanse-8b',
     'command',
@@ -67,9 +67,15 @@
     'command-r-plus-08-2024',
     'command-r7b-12-2024',
 ]
-"""Latest / most popular named Cohere models."""
+"""Latest Cohere models."""
 
-CohereModelName = Union[NamedCohereModels, str]
+CohereModelName = Union[str, LatestCohereModelNames]
+"""Possible Cohere model names.
+
+Since Cohere supports a variety of date-stamped models, we explicitly list the latest models but
+allow any name in the type hints.
+See [Cohere's docs](https://docs.cohere.com/v2/docs/models) for a list of all available models.
+"""
 
 
 class CohereModelSettings(ModelSettings):
@@ -88,9 +94,11 @@ class CohereModel(Model):
     Apart from `__init__`, all methods are private or match those of the base class.
     """
 
-    model_name: CohereModelName
     client: AsyncClientV2 = field(repr=False)
 
+    _model_name: CohereModelName = field(repr=False)
+    _system: str | None = field(default='cohere', repr=False)
+
     def __init__(
         self,
         model_name: CohereModelName,
@@ -110,17 +118,14 @@ def __init__(
                 `api_key` and `http_client` must be `None`.
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
-        self.model_name: CohereModelName = model_name
+        self._model_name: CohereModelName = model_name
         if cohere_client is not None:
             assert http_client is None, 'Cannot provide both `cohere_client` and `http_client`'
             assert api_key is None, 'Cannot provide both `cohere_client` and `api_key`'
             self.client = cohere_client
         else:
             self.client = AsyncClientV2(api_key=api_key, httpx_client=http_client)  # type: ignore
 
-    def name(self) -> str:
-        return f'cohere:{self.model_name}'
-
     async def request(
         self,
         messages: list[ModelMessage],
@@ -140,7 +145,7 @@ async def _chat(
         tools = self._get_tools(model_request_parameters)
         cohere_messages = list(chain(*(self._map_message(m) for m in messages)))
         return await self.client.chat(
-            model=self.model_name,
+            model=self._model_name,
             messages=cohere_messages,
             tools=tools or OMIT,
             max_tokens=model_settings.get('max_tokens', OMIT),
@@ -168,7 +173,7 @@ def _process_response(self, response: ChatResponse) -> ModelResponse:
                         tool_call_id=c.id,
                     )
                 )
-        return ModelResponse(parts=parts, model_name=self.model_name)
+        return ModelResponse(parts=parts, model_name=self._model_name)
 
     def _map_message(self, message: ModelMessage) -> Iterable[ChatMessageV2]:
         """Just maps a `pydantic_ai.Message` to a `cohere.ChatMessageV2`."""

pydantic_ai_slim/pydantic_ai/models/function.py

@@ -40,6 +40,9 @@ class FunctionModel(Model):
     function: FunctionDef | None = None
     stream_function: StreamFunctionDef | None = None
 
+    _model_name: str = field(repr=False)
+    _system: str | None = field(default=None, repr=False)
+
     @overload
     def __init__(self, function: FunctionDef) -> None: ...
 
@@ -63,10 +66,9 @@ def __init__(self, function: FunctionDef | None = None, *, stream_function: Stre
         self.function = function
         self.stream_function = stream_function
 
-    def name(self) -> str:
         function_name = self.function.__name__ if self.function is not None else ''
         stream_function_name = self.stream_function.__name__ if self.stream_function is not None else ''
-        return f'function:{function_name}:{stream_function_name}'
+        self._model_name = f'function:{function_name}:{stream_function_name}'
 
     async def request(
         self,
@@ -82,15 +84,14 @@ async def request(
         )
 
         assert self.function is not None, 'FunctionModel must receive a `function` to support non-streamed requests'
-        model_name = f'function:{self.function.__name__}'
 
         if inspect.iscoroutinefunction(self.function):
             response = await self.function(messages, agent_info)
         else:
             response_ = await _utils.run_in_executor(self.function, messages, agent_info)
             assert isinstance(response_, ModelResponse), response_
             response = response_
-        response.model_name = model_name
+        response.model_name = f'function:{self.function.__name__}'
         # TODO is `messages` right here? Should it just be new messages?
         return response, _estimate_usage(chain(messages, [response]))
 
@@ -111,15 +112,14 @@ async def request_stream(
         assert (
             self.stream_function is not None
         ), 'FunctionModel must receive a `stream_function` to support streamed requests'
-        model_name = f'function:{self.stream_function.__name__}'
 
         response_stream = PeekableAsyncStream(self.stream_function(messages, agent_info))
 
         first = await response_stream.peek()
         if isinstance(first, _utils.Unset):
             raise ValueError('Stream function must return at least one item')
 
-        yield FunctionStreamedResponse(_model_name=model_name, _iter=response_stream)
+        yield FunctionStreamedResponse(_model_name=f'function:{self.stream_function.__name__}', _iter=response_stream)
 
 
 @dataclass(frozen=True)

pydantic_ai_slim/pydantic_ai/models/gemini.py

@@ -39,7 +39,7 @@
     get_user_agent,
 )
 
-GeminiModelName = Literal[
+LatestGeminiModelNames = Literal[
     'gemini-1.5-flash',
     'gemini-1.5-flash-8b',
     'gemini-1.5-pro',
@@ -48,8 +48,13 @@
     'gemini-2.0-flash-thinking-exp-01-21',
     'gemini-exp-1206',
 ]
-"""Named Gemini models.
+"""Latest Gemini models."""
 
+GeminiModelName = Union[str, LatestGeminiModelNames]
+"""Possible Gemini model names.
+
+Since Gemini supports a variety of date-stamped models, we explicitly list the latest models but
+allow any name in the type hints.
 See [the Gemini API docs](https://ai.google.dev/gemini-api/docs/models/gemini#model-variations) for a full list.
 """
 
@@ -70,11 +75,12 @@ class GeminiModel(Model):
     Apart from `__init__`, all methods are private or match those of the base class.
     """
 
-    model_name: GeminiModelName
-    http_client: AsyncHTTPClient
+    http_client: AsyncHTTPClient = field(repr=False)
 
-    _auth: AuthProtocol | None
-    _url: str | None
+    _model_name: GeminiModelName = field(repr=False)
+    _auth: AuthProtocol | None = field(repr=False)
+    _url: str | None = field(repr=False)
+    _system: str | None = field(default='google-gla', repr=False)
 
     def __init__(
         self,
@@ -95,7 +101,7 @@ def __init__(
                 docs [here](https://ai.google.dev/gemini-api/docs/quickstart?lang=rest#make-first-request),
                 `model` is substituted with the model name, and `function` is added to the end of the URL.
         """
-        self.model_name = model_name
+        self._model_name = model_name
         if api_key is None:
             if env_api_key := os.getenv('GEMINI_API_KEY'):
                 api_key = env_api_key
@@ -115,9 +121,6 @@ def url(self) -> str:
         assert self._url is not None, 'URL not initialized'
         return self._url
 
-    def name(self) -> str:
-        return f'google-gla:{self.model_name}'
-
     async def request(
         self,
         messages: list[ModelMessage],
@@ -228,7 +231,7 @@ def _process_response(self, response: _GeminiResponse) -> ModelResponse:
             else:
                 raise UnexpectedModelBehavior('Content field missing from Gemini response', str(response))
         parts = response['candidates'][0]['content']['parts']
-        return _process_response_from_parts(parts, model_name=self.model_name)
+        return _process_response_from_parts(parts, model_name=self._model_name)
 
     async def _process_streamed_response(self, http_response: HTTPResponse) -> StreamedResponse:
         """Process a streamed response, and prepare a streaming response to return."""
@@ -251,7 +254,7 @@ async def _process_streamed_response(self, http_response: HTTPResponse) -> Strea
         if start_response is None:
             raise UnexpectedModelBehavior('Streamed response ended without content or tool calls')
 
-        return GeminiStreamedResponse(_model_name=self.model_name, _content=content, _stream=aiter_bytes)
+        return GeminiStreamedResponse(_model_name=self._model_name, _content=content, _stream=aiter_bytes)
 
     @classmethod
     def _message_to_gemini_content(