pydantic-ai-slim 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

pydantic_ai/models/groq.py

@@ -1,5 +1,6 @@
 from __future__ import annotations as _annotations
 
+import base64
 from collections.abc import AsyncIterable, AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
@@ -13,6 +14,8 @@ from typing_extensions import assert_never
 from .. import UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
+    BinaryContent,
+    ImageUrl,
     ModelMessage,
     ModelRequest,
     ModelResponse,
@@ -38,7 +41,7 @@ from . import (
 try:
     from groq import NOT_GIVEN, AsyncGroq, AsyncStream
     from groq.types import chat
-    from groq.types.chat import ChatCompletion, ChatCompletionChunk
+    from groq.types.chat.chat_completion_content_part_image_param import ImageURL
 except ImportError as _import_error:
     raise ImportError(
         'Please install `groq` to use the Groq model, '
@@ -163,7 +166,7 @@ class GroqModel(Model):
         stream: Literal[True],
         model_settings: GroqModelSettings,
         model_request_parameters: ModelRequestParameters,
-    ) -> AsyncStream[ChatCompletionChunk]:
+    ) -> AsyncStream[chat.ChatCompletionChunk]:
         pass
 
     @overload
@@ -182,7 +185,7 @@ class GroqModel(Model):
         stream: bool,
         model_settings: GroqModelSettings,
         model_request_parameters: ModelRequestParameters,
-    ) -> chat.ChatCompletion | AsyncStream[ChatCompletionChunk]:
+    ) -> chat.ChatCompletion | AsyncStream[chat.ChatCompletionChunk]:
         tools = self._get_tools(model_request_parameters)
         # standalone function to make it easier to override
         if not tools:
@@ -224,7 +227,7 @@ class GroqModel(Model):
                 items.append(ToolCallPart(tool_name=c.function.name, args=c.function.arguments, tool_call_id=c.id))
         return ModelResponse(items, model_name=response.model, timestamp=timestamp)
 
-    async def _process_streamed_response(self, response: AsyncStream[ChatCompletionChunk]) -> GroqStreamedResponse:
+    async def _process_streamed_response(self, response: AsyncStream[chat.ChatCompletionChunk]) -> GroqStreamedResponse:
         """Process a streamed response, and prepare a streaming response to return."""
         peekable_response = _utils.PeekableAsyncStream(response)
         first_chunk = await peekable_response.peek()
@@ -293,7 +296,7 @@ class GroqModel(Model):
             if isinstance(part, SystemPromptPart):
                 yield chat.ChatCompletionSystemMessageParam(role='system', content=part.content)
             elif isinstance(part, UserPromptPart):
-                yield chat.ChatCompletionUserMessageParam(role='user', content=part.content)
+                yield cls._map_user_prompt(part)
             elif isinstance(part, ToolReturnPart):
                 yield chat.ChatCompletionToolMessageParam(
                     role='tool',
@@ -310,13 +313,37 @@ class GroqModel(Model):
                         content=part.model_response(),
                     )
 
+    @staticmethod
+    def _map_user_prompt(part: UserPromptPart) -> chat.ChatCompletionUserMessageParam:
+        content: str | list[chat.ChatCompletionContentPartParam]
+        if isinstance(part.content, str):
+            content = part.content
+        else:
+            content = []
+            for item in part.content:
+                if isinstance(item, str):
+                    content.append(chat.ChatCompletionContentPartTextParam(text=item, type='text'))
+                elif isinstance(item, ImageUrl):
+                    image_url = ImageURL(url=item.url)
+                    content.append(chat.ChatCompletionContentPartImageParam(image_url=image_url, type='image_url'))
+                elif isinstance(item, BinaryContent):
+                    base64_encoded = base64.b64encode(item.data).decode('utf-8')
+                    if item.is_image:
+                        image_url = ImageURL(url=f'data:{item.media_type};base64,{base64_encoded}')
+                        content.append(chat.ChatCompletionContentPartImageParam(image_url=image_url, type='image_url'))
+                    else:
+                        raise RuntimeError('Only images are supported for binary content in Groq.')
+                else:  # pragma: no cover
+                    raise RuntimeError(f'Unsupported content type: {type(item)}')
+        return chat.ChatCompletionUserMessageParam(role='user', content=content)
+
 
 @dataclass
 class GroqStreamedResponse(StreamedResponse):
     """Implementation of `StreamedResponse` for Groq models."""
 
     _model_name: GroqModelName
-    _response: AsyncIterable[ChatCompletionChunk]
+    _response: AsyncIterable[chat.ChatCompletionChunk]
     _timestamp: datetime
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
@@ -355,9 +382,9 @@ class GroqStreamedResponse(StreamedResponse):
         return self._timestamp
 
 
-def _map_usage(completion: ChatCompletionChunk | ChatCompletion) -> usage.Usage:
+def _map_usage(completion: chat.ChatCompletionChunk | chat.ChatCompletion) -> usage.Usage:
     response_usage = None
-    if isinstance(completion, ChatCompletion):
+    if isinstance(completion, chat.ChatCompletion):
         response_usage = completion.usage
     elif completion.x_groq is not None:
         response_usage = completion.x_groq.usage

pydantic_ai/models/instrumented.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Iterator
+from contextlib import asynccontextmanager, contextmanager
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Any, Callable, Literal
+
+import logfire_api
+from opentelemetry._events import Event, EventLogger, EventLoggerProvider, get_event_logger_provider
+from opentelemetry.trace import Tracer, TracerProvider, get_tracer_provider
+
+from ..messages import (
+    ModelMessage,
+    ModelRequest,
+    ModelRequestPart,
+    ModelResponse,
+    RetryPromptPart,
+    SystemPromptPart,
+    TextPart,
+    ToolCallPart,
+    ToolReturnPart,
+    UserPromptPart,
+)
+from ..settings import ModelSettings
+from ..usage import Usage
+from . import KnownModelName, Model, ModelRequestParameters, StreamedResponse
+from .wrapper import WrapperModel
+
+MODEL_SETTING_ATTRIBUTES: tuple[
+    Literal[
+        'max_tokens',
+        'top_p',
+        'seed',
+        'temperature',
+        'presence_penalty',
+        'frequency_penalty',
+    ],
+    ...,
+] = (
+    'max_tokens',
+    'top_p',
+    'seed',
+    'temperature',
+    'presence_penalty',
+    'frequency_penalty',
+)
+
+NOT_GIVEN = object()
+
+
+@dataclass
+class InstrumentedModel(WrapperModel):
+    """Model which is instrumented with logfire."""
+
+    tracer: Tracer = field(repr=False)
+    event_logger: EventLogger = field(repr=False)
+
+    def __init__(
+        self,
+        wrapped: Model | KnownModelName,
+        tracer_provider: TracerProvider | None = None,
+        event_logger_provider: EventLoggerProvider | None = None,
+    ):
+        super().__init__(wrapped)
+        tracer_provider = tracer_provider or get_tracer_provider()
+        event_logger_provider = event_logger_provider or get_event_logger_provider()
+        self.tracer = tracer_provider.get_tracer('pydantic-ai')
+        self.event_logger = event_logger_provider.get_event_logger('pydantic-ai')
+
+    @classmethod
+    def from_logfire(
+        cls,
+        wrapped: Model | KnownModelName,
+        logfire_instance: logfire_api.Logfire = logfire_api.DEFAULT_LOGFIRE_INSTANCE,
+    ) -> InstrumentedModel:
+        if hasattr(logfire_instance.config, 'get_event_logger_provider'):
+            event_provider = logfire_instance.config.get_event_logger_provider()
+        else:
+            event_provider = None
+        tracer_provider = logfire_instance.config.get_tracer_provider()
+        return cls(wrapped, tracer_provider, event_provider)
+
+    async def request(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> tuple[ModelResponse, Usage]:
+        with self._instrument(messages, model_settings) as finish:
+            response, usage = await super().request(messages, model_settings, model_request_parameters)
+            finish(response, usage)
+            return response, usage
+
+    @asynccontextmanager
+    async def request_stream(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> AsyncIterator[StreamedResponse]:
+        with self._instrument(messages, model_settings) as finish:
+            response_stream: StreamedResponse | None = None
+            try:
+                async with super().request_stream(
+                    messages, model_settings, model_request_parameters
+                ) as response_stream:
+                    yield response_stream
+            finally:
+                if response_stream:
+                    finish(response_stream.get(), response_stream.usage())
+
+    @contextmanager
+    def _instrument(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+    ) -> Iterator[Callable[[ModelResponse, Usage], None]]:
+        operation = 'chat'
+        model_name = self.model_name
+        span_name = f'{operation} {model_name}'
+        system = getattr(self.wrapped, 'system', '') or self.wrapped.__class__.__name__.removesuffix('Model').lower()
+        system = {'google-gla': 'gemini', 'google-vertex': 'vertex_ai', 'mistral': 'mistral_ai'}.get(system, system)
+        # TODO Missing attributes:
+        #  - server.address: requires a Model.base_url abstract method or similar
+        #  - server.port: to parse from the base_url
+        #  - error.type: unclear if we should do something here or just always rely on span exceptions
+        #  - gen_ai.request.stop_sequences/top_k: model_settings doesn't include these
+        attributes: dict[str, Any] = {
+            'gen_ai.operation.name': operation,
+            'gen_ai.system': system,
+            'gen_ai.request.model': model_name,
+        }
+
+        if model_settings:
+            for key in MODEL_SETTING_ATTRIBUTES:
+                if (value := model_settings.get(key, NOT_GIVEN)) is not NOT_GIVEN:
+                    attributes[f'gen_ai.request.{key}'] = value
+
+        emit_event = partial(self._emit_event, system)
+
+        with self.tracer.start_as_current_span(span_name, attributes=attributes) as span:
+            if span.is_recording():
+                for message in messages:
+                    if isinstance(message, ModelRequest):
+                        for part in message.parts:
+                            event_name, body = _request_part_body(part)
+                            if event_name:
+                                emit_event(event_name, body)
+                    elif isinstance(message, ModelResponse):
+                        for body in _response_bodies(message):
+                            emit_event('gen_ai.assistant.message', body)
+
+            def finish(response: ModelResponse, usage: Usage):
+                if not span.is_recording():
+                    return
+
+                for response_body in _response_bodies(response):
+                    if response_body:
+                        emit_event(
+                            'gen_ai.choice',
+                            {
+                                # TODO finish_reason
+                                'index': 0,
+                                'message': response_body,
+                            },
+                        )
+                span.set_attributes(
+                    {
+                        k: v
+                        for k, v in {
+                            # TODO finish_reason (https://github.com/open-telemetry/semantic-conventions/issues/1277), id
+                            #  https://github.com/pydantic/pydantic-ai/issues/886
+                            'gen_ai.response.model': response.model_name or model_name,
+                            'gen_ai.usage.input_tokens': usage.request_tokens,
+                            'gen_ai.usage.output_tokens': usage.response_tokens,
+                        }.items()
+                        if v is not None
+                    }
+                )
+
+            yield finish
+
+    def _emit_event(self, system: str, event_name: str, body: dict[str, Any]) -> None:
+        self.event_logger.emit(Event(event_name, body=body, attributes={'gen_ai.system': system}))
+
+
+def _request_part_body(part: ModelRequestPart) -> tuple[str, dict[str, Any]]:
+    if isinstance(part, SystemPromptPart):
+        return 'gen_ai.system.message', {'content': part.content, 'role': 'system'}
+    elif isinstance(part, UserPromptPart):
+        return 'gen_ai.user.message', {'content': part.content, 'role': 'user'}
+    elif isinstance(part, ToolReturnPart):
+        return 'gen_ai.tool.message', {'content': part.content, 'role': 'tool', 'id': part.tool_call_id}
+    elif isinstance(part, RetryPromptPart):
+        if part.tool_name is None:
+            return 'gen_ai.user.message', {'content': part.model_response(), 'role': 'user'}
+        else:
+            return 'gen_ai.tool.message', {'content': part.model_response(), 'role': 'tool', 'id': part.tool_call_id}
+    else:
+        return '', {}
+
+
+def _response_bodies(message: ModelResponse) -> list[dict[str, Any]]:
+    body: dict[str, Any] = {'role': 'assistant'}
+    result = [body]
+    for part in message.parts:
+        if isinstance(part, ToolCallPart):
+            body.setdefault('tool_calls', []).append(
+                {
+                    'id': part.tool_call_id,
+                    'type': 'function',  # TODO https://github.com/pydantic/pydantic-ai/issues/888
+                    'function': {
+                        'name': part.tool_name,
+                        'arguments': part.args,
+                    },
+                }
+            )
+        elif isinstance(part, TextPart):
+            if body.get('content'):
+                body = {'role': 'assistant'}
+                result.append(body)
+            body['content'] = part.content
+
+    return result

pydantic_ai/models/mistral.py

@@ -1,5 +1,6 @@
 from __future__ import annotations as _annotations
 
+import base64
 import os
 from collections.abc import AsyncIterable, AsyncIterator, Iterable
 from contextlib import asynccontextmanager
@@ -15,6 +16,8 @@ from typing_extensions import assert_never
 from .. import UnexpectedModelBehavior, _utils
 from .._utils import now_utc as _now_utc
 from ..messages import (
+    BinaryContent,
+    ImageUrl,
     ModelMessage,
     ModelRequest,
     ModelResponse,
@@ -45,6 +48,8 @@ try:
         Content as MistralContent,
         ContentChunk as MistralContentChunk,
         FunctionCall as MistralFunctionCall,
+        ImageURL as MistralImageURL,
+        ImageURLChunk as MistralImageURLChunk,
         Mistral,
         OptionalNullable as MistralOptionalNullable,
         TextChunk as MistralTextChunk,
@@ -134,9 +139,6 @@ class MistralModel(Model):
             api_key = os.getenv('MISTRAL_API_KEY') if api_key is None else api_key
             self.client = Mistral(api_key=api_key, async_client=http_client or cached_async_http_client())
 
-    def name(self) -> str:
-        return f'mistral:{self._model_name}'
-
     async def request(
         self,
         messages: list[ModelMessage],
@@ -426,7 +428,7 @@ class MistralModel(Model):
             if isinstance(part, SystemPromptPart):
                 yield MistralSystemMessage(content=part.content)
             elif isinstance(part, UserPromptPart):
-                yield MistralUserMessage(content=part.content)
+                yield cls._map_user_prompt(part)
             elif isinstance(part, ToolReturnPart):
                 yield MistralToolMessage(
                     tool_call_id=part.tool_call_id,
@@ -463,6 +465,29 @@ class MistralModel(Model):
         else:
             assert_never(message)
 
+    @staticmethod
+    def _map_user_prompt(part: UserPromptPart) -> MistralUserMessage:
+        content: str | list[MistralContentChunk]
+        if isinstance(part.content, str):
+            content = part.content
+        else:
+            content = []
+            for item in part.content:
+                if isinstance(item, str):
+                    content.append(MistralTextChunk(text=item))
+                elif isinstance(item, ImageUrl):
+                    content.append(MistralImageURLChunk(image_url=MistralImageURL(url=item.url)))
+                elif isinstance(item, BinaryContent):
+                    base64_encoded = base64.b64encode(item.data).decode('utf-8')
+                    if item.is_image:
+                        image_url = MistralImageURL(url=f'data:{item.media_type};base64,{base64_encoded}')
+                        content.append(MistralImageURLChunk(image_url=image_url, type='image_url'))
+                    else:
+                        raise RuntimeError('Only image binary content is supported for Mistral.')
+                else:  # pragma: no cover
+                    raise RuntimeError(f'Unsupported content type: {type(item)}')
+        return MistralUserMessage(content=content)
+
 
 MistralToolCallId = Union[str, None]
 

pydantic_ai/models/openai.py

@@ -1,11 +1,11 @@
 from __future__ import annotations as _annotations
 
+import base64
 import os
-from collections.abc import AsyncIterable, AsyncIterator, Iterable
+from collections.abc import AsyncIterable, AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from itertools import chain
 from typing import Literal, Union, cast, overload
 
 from httpx import AsyncClient as AsyncHTTPClient
@@ -14,6 +14,9 @@ from typing_extensions import assert_never
 from .. import UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
+    AudioUrl,
+    BinaryContent,
+    ImageUrl,
     ModelMessage,
     ModelRequest,
     ModelResponse,
@@ -39,7 +42,15 @@ from . import (
 try:
     from openai import NOT_GIVEN, AsyncOpenAI, AsyncStream
     from openai.types import ChatModel, chat
-    from openai.types.chat import ChatCompletionChunk
+    from openai.types.chat import (
+        ChatCompletionChunk,
+        ChatCompletionContentPartImageParam,
+        ChatCompletionContentPartInputAudioParam,
+        ChatCompletionContentPartParam,
+        ChatCompletionContentPartTextParam,
+    )
+    from openai.types.chat.chat_completion_content_part_image_param import ImageURL
+    from openai.types.chat.chat_completion_content_part_input_audio_param import InputAudio
 except ImportError as _import_error:
     raise ImportError(
         'Please install `openai` to use the OpenAI model, '
@@ -119,9 +130,9 @@ class OpenAIModel(Model):
         """
         self._model_name = model_name
         # This is a workaround for the OpenAI client requiring an API key, whilst locally served,
-        # openai compatible models do not always need an API key.
+        # openai compatible models do not always need an API key, but a placeholder (non-empty) key is required.
         if api_key is None and 'OPENAI_API_KEY' not in os.environ and base_url is not None and openai_client is None:
-            api_key = ''
+            api_key = 'api-key-not-set'
 
         if openai_client is not None:
             assert http_client is None, 'Cannot provide both `openai_client` and `http_client`'
@@ -135,9 +146,6 @@ class OpenAIModel(Model):
         self.system_prompt_role = system_prompt_role
         self._system = system
 
-    def name(self) -> str:
-        return f'openai:{self._model_name}'
-
     async def request(
         self,
         messages: list[ModelMessage],
@@ -211,7 +219,10 @@ class OpenAIModel(Model):
         else:
             tool_choice = 'auto'
 
-        openai_messages = list(chain(*(self._map_message(m) for m in messages)))
+        openai_messages: list[chat.ChatCompletionMessageParam] = []
+        for m in messages:
+            async for msg in self._map_message(m):
+                openai_messages.append(msg)
 
         return await self.client.chat.completions.create(
             model=self._model_name,
@@ -264,10 +275,11 @@ class OpenAIModel(Model):
             tools += [self._map_tool_definition(r) for r in model_request_parameters.result_tools]
         return tools
 
-    def _map_message(self, message: ModelMessage) -> Iterable[chat.ChatCompletionMessageParam]:
+    async def _map_message(self, message: ModelMessage) -> AsyncIterable[chat.ChatCompletionMessageParam]:
         """Just maps a `pydantic_ai.Message` to a `openai.types.ChatCompletionMessageParam`."""
         if isinstance(message, ModelRequest):
-            yield from self._map_user_message(message)
+            async for item in self._map_user_message(message):
+                yield item
         elif isinstance(message, ModelResponse):
             texts: list[str] = []
             tool_calls: list[chat.ChatCompletionMessageToolCallParam] = []
@@ -308,7 +320,7 @@ class OpenAIModel(Model):
             },
         }
 
-    def _map_user_message(self, message: ModelRequest) -> Iterable[chat.ChatCompletionMessageParam]:
+    async def _map_user_message(self, message: ModelRequest) -> AsyncIterable[chat.ChatCompletionMessageParam]:
         for part in message.parts:
             if isinstance(part, SystemPromptPart):
                 if self.system_prompt_role == 'developer':
@@ -318,7 +330,7 @@ class OpenAIModel(Model):
                 else:
                     yield chat.ChatCompletionSystemMessageParam(role='system', content=part.content)
             elif isinstance(part, UserPromptPart):
-                yield chat.ChatCompletionUserMessageParam(role='user', content=part.content)
+                yield await self._map_user_prompt(part)
             elif isinstance(part, ToolReturnPart):
                 yield chat.ChatCompletionToolMessageParam(
                     role='tool',
@@ -337,6 +349,40 @@ class OpenAIModel(Model):
             else:
                 assert_never(part)
 
+    @staticmethod
+    async def _map_user_prompt(part: UserPromptPart) -> chat.ChatCompletionUserMessageParam:
+        content: str | list[ChatCompletionContentPartParam]
+        if isinstance(part.content, str):
+            content = part.content
+        else:
+            content = []
+            for item in part.content:
+                if isinstance(item, str):
+                    content.append(ChatCompletionContentPartTextParam(text=item, type='text'))
+                elif isinstance(item, ImageUrl):
+                    image_url = ImageURL(url=item.url)
+                    content.append(ChatCompletionContentPartImageParam(image_url=image_url, type='image_url'))
+                elif isinstance(item, BinaryContent):
+                    base64_encoded = base64.b64encode(item.data).decode('utf-8')
+                    if item.is_image:
+                        image_url = ImageURL(url=f'data:{item.media_type};base64,{base64_encoded}')
+                        content.append(ChatCompletionContentPartImageParam(image_url=image_url, type='image_url'))
+                    elif item.is_audio:
+                        audio = InputAudio(data=base64_encoded, format=item.audio_format)
+                        content.append(ChatCompletionContentPartInputAudioParam(input_audio=audio, type='input_audio'))
+                    else:  # pragma: no cover
+                        raise RuntimeError(f'Unsupported binary content type: {item.media_type}')
+                elif isinstance(item, AudioUrl):  # pragma: no cover
+                    client = cached_async_http_client()
+                    response = await client.get(item.url)
+                    response.raise_for_status()
+                    base64_encoded = base64.b64encode(response.content).decode('utf-8')
+                    audio = InputAudio(data=base64_encoded, format=response.headers.get('content-type'))
+                    content.append(ChatCompletionContentPartInputAudioParam(input_audio=audio, type='input_audio'))
+                else:
+                    assert_never(item)
+        return chat.ChatCompletionUserMessageParam(role='user', content=content)
+
 
 @dataclass
 class OpenAIStreamedResponse(StreamedResponse):

pydantic_ai/models/test.py

@@ -130,15 +130,15 @@ class TestModel(Model):
 
     def _get_result(self, model_request_parameters: ModelRequestParameters) -> _TextResult | _FunctionToolResult:
         if self.custom_result_text is not None:
-            assert (
-                model_request_parameters.allow_text_result
-            ), 'Plain response not allowed, but `custom_result_text` is set.'
+            assert model_request_parameters.allow_text_result, (
+                'Plain response not allowed, but `custom_result_text` is set.'
+            )
             assert self.custom_result_args is None, 'Cannot set both `custom_result_text` and `custom_result_args`.'
             return _TextResult(self.custom_result_text)
         elif self.custom_result_args is not None:
-            assert (
-                model_request_parameters.result_tools is not None
-            ), 'No result tools provided, but `custom_result_args` is set.'
+            assert model_request_parameters.result_tools is not None, (
+                'No result tools provided, but `custom_result_args` is set.'
+            )
             result_tool = model_request_parameters.result_tools[0]
 
             if k := result_tool.outer_typed_dict_key:

pydantic_ai/models/wrapper.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Any
+
+from ..messages import ModelMessage, ModelResponse
+from ..settings import ModelSettings
+from ..usage import Usage
+from . import KnownModelName, Model, ModelRequestParameters, StreamedResponse, infer_model
+
+
+@dataclass(init=False)
+class WrapperModel(Model):
+    """Model which wraps another model."""
+
+    wrapped: Model
+
+    def __init__(self, wrapped: Model | KnownModelName):
+        self.wrapped = infer_model(wrapped)
+
+    async def request(self, *args: Any, **kwargs: Any) -> tuple[ModelResponse, Usage]:
+        return await self.wrapped.request(*args, **kwargs)
+
+    @asynccontextmanager
+    async def request_stream(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> AsyncIterator[StreamedResponse]:
+        async with self.wrapped.request_stream(messages, model_settings, model_request_parameters) as response_stream:
+            yield response_stream
+
+    @property
+    def model_name(self) -> str:
+        return self.wrapped.model_name
+
+    @property
+    def system(self) -> str | None:
+        return self.wrapped.system
+
+    def __getattr__(self, item: str):
+        return getattr(self.wrapped, item)