pydantic-ai-slim 0.4.2__tar.gz → 0.4.3__tar.gz

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.4.2
+Version: 0.4.3
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT
@@ -30,7 +30,7 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.4.2
+Requires-Dist: pydantic-graph==0.4.3
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -46,13 +46,15 @@ Requires-Dist: rich>=13; extra == 'cli'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == 'cohere'
 Provides-Extra: duckduckgo
-Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
+Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.4.2; extra == 'evals'
+Requires-Dist: pydantic-evals==0.4.3; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.24.0; extra == 'google'
 Provides-Extra: groq
 Requires-Dist: groq>=0.19.0; extra == 'groq'
+Provides-Extra: huggingface
+Requires-Dist: huggingface-hub[inference]>=0.33.2; extra == 'huggingface'
 Provides-Extra: logfire
 Requires-Dist: logfire>=3.11.0; extra == 'logfire'
 Provides-Extra: mcp

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/_agent_graph.py

@@ -341,6 +341,7 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
                 ctx.deps.output_schema,
                 ctx.deps.output_validators,
                 build_run_context(ctx),
+                _output.build_trace_context(ctx),
                 ctx.deps.usage_limits,
             )
             yield agent_stream
@@ -529,7 +530,8 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         if isinstance(output_schema, _output.ToolOutputSchema):
             for call, output_tool in output_schema.find_tool(tool_calls):
                 try:
-                    result_data = await output_tool.process(call, run_context)
+                    trace_context = _output.build_trace_context(ctx)
+                    result_data = await output_tool.process(call, run_context, trace_context)
                     result_data = await _validate_output(result_data, ctx, call)
                 except _output.ToolRetryError as e:
                     # TODO: Should only increment retry stuff once per node execution, not for each tool call
@@ -586,7 +588,8 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         try:
             if isinstance(output_schema, _output.TextOutputSchema):
                 run_context = build_run_context(ctx)
-                result_data = await output_schema.process(text, run_context)
+                trace_context = _output.build_trace_context(ctx)
+                result_data = await output_schema.process(text, run_context, trace_context)
             else:
                 m = _messages.RetryPromptPart(
                     content='Plain text responses are not permitted, please include your response in a tool call',

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/_output.py

@@ -1,5 +1,6 @@
 from __future__ import annotations as _annotations
 
+import dataclasses
 import inspect
 import json
 from abc import ABC, abstractmethod
@@ -7,10 +8,13 @@ from collections.abc import Awaitable, Iterable, Iterator, Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, Union, cast, overload
 
+from opentelemetry.trace import Tracer
 from pydantic import TypeAdapter, ValidationError
 from pydantic_core import SchemaValidator
 from typing_extensions import TypedDict, TypeVar, assert_never
 
+from pydantic_graph.nodes import GraphRunContext
+
 from . import _function_schema, _utils, messages as _messages
 from ._run_context import AgentDepsT, RunContext
 from .exceptions import ModelRetry, UserError
@@ -29,6 +33,8 @@ from .output import (
 from .tools import GenerateToolJsonSchema, ObjectJsonSchema, ToolDefinition
 
 if TYPE_CHECKING:
+    from pydantic_ai._agent_graph import DepsT, GraphAgentDeps, GraphAgentState
+
     from .profiles import ModelProfile
 
 T = TypeVar('T')
@@ -66,6 +72,71 @@ DEFAULT_OUTPUT_TOOL_NAME = 'final_result'
 DEFAULT_OUTPUT_TOOL_DESCRIPTION = 'The final response which ends this conversation'
 
 
+@dataclass(frozen=True)
+class TraceContext:
+    """A context for tracing output processing."""
+
+    tracer: Tracer
+    include_content: bool
+    call: _messages.ToolCallPart | None = None
+
+    def with_call(self, call: _messages.ToolCallPart):
+        return dataclasses.replace(self, call=call)
+
+    async def execute_function_with_span(
+        self,
+        function_schema: _function_schema.FunctionSchema,
+        run_context: RunContext[AgentDepsT],
+        args: dict[str, Any] | Any,
+        call: _messages.ToolCallPart,
+        include_tool_call_id: bool = True,
+    ) -> Any:
+        """Execute a function call within a traced span, automatically recording the response."""
+        # Set up span attributes
+        attributes = {
+            'gen_ai.tool.name': call.tool_name,
+            'logfire.msg': f'running output function: {call.tool_name}',
+        }
+        if include_tool_call_id:
+            attributes['gen_ai.tool.call.id'] = call.tool_call_id
+        if self.include_content:
+            attributes['tool_arguments'] = call.args_as_json_str()
+            attributes['logfire.json_schema'] = json.dumps(
+                {
+                    'type': 'object',
+                    'properties': {
+                        'tool_arguments': {'type': 'object'},
+                        'tool_response': {'type': 'object'},
+                    },
+                }
+            )
+
+        # Execute function within span
+        with self.tracer.start_as_current_span('running output function', attributes=attributes) as span:
+            output = await function_schema.call(args, run_context)
+
+            # Record response if content inclusion is enabled
+            if self.include_content and span.is_recording():
+                from .models.instrumented import InstrumentedModel
+
+                span.set_attribute(
+                    'tool_response',
+                    output if isinstance(output, str) else json.dumps(InstrumentedModel.serialize_any(output)),
+                )
+
+            return output
+
+
+def build_trace_context(ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, Any]]) -> TraceContext:
+    """Build a `TraceContext` from the current agent graph run context."""
+    return TraceContext(
+        tracer=ctx.deps.tracer,
+        include_content=(
+            ctx.deps.instrumentation_settings is not None and ctx.deps.instrumentation_settings.include_content
+        ),
+    )
+
+
 class ToolRetryError(Exception):
     """Exception used to signal a `ToolRetry` message should be returned to the LLM."""
 
@@ -96,6 +167,7 @@ class OutputValidator(Generic[AgentDepsT, OutputDataT_inv]):
             result: The result data after Pydantic validation the message content.
             tool_call: The original tool call message, `None` if there was no tool call.
             run_context: The current run context.
+            trace_context: The trace context to use for tracing the output processing.
 
         Returns:
             Result of either the validated result data (ok) or a retry message (Err).
@@ -349,6 +421,7 @@ class TextOutputSchema(OutputSchema[OutputDataT], ABC):
         self,
         text: str,
         run_context: RunContext[AgentDepsT],
+        trace_context: TraceContext,
         allow_partial: bool = False,
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
@@ -371,6 +444,7 @@ class PlainTextOutputSchema(TextOutputSchema[OutputDataT]):
         self,
         text: str,
         run_context: RunContext[AgentDepsT],
+        trace_context: TraceContext,
         allow_partial: bool = False,
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
@@ -379,6 +453,7 @@ class PlainTextOutputSchema(TextOutputSchema[OutputDataT]):
         Args:
             text: The output text to validate.
             run_context: The current run context.
+            trace_context: The trace context to use for tracing the output processing.
             allow_partial: If true, allow partial validation.
             wrap_validation_errors: If true, wrap the validation errors in a retry message.
 
@@ -389,7 +464,7 @@ class PlainTextOutputSchema(TextOutputSchema[OutputDataT]):
             return cast(OutputDataT, text)
 
         return await self.processor.process(
-            text, run_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
+            text, run_context, trace_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
         )
 
 
@@ -417,6 +492,7 @@ class NativeOutputSchema(StructuredTextOutputSchema[OutputDataT]):
         self,
         text: str,
         run_context: RunContext[AgentDepsT],
+        trace_context: TraceContext,
         allow_partial: bool = False,
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
@@ -425,6 +501,7 @@ class NativeOutputSchema(StructuredTextOutputSchema[OutputDataT]):
         Args:
             text: The output text to validate.
             run_context: The current run context.
+            trace_context: The trace context to use for tracing the output processing.
             allow_partial: If true, allow partial validation.
             wrap_validation_errors: If true, wrap the validation errors in a retry message.
 
@@ -432,7 +509,7 @@ class NativeOutputSchema(StructuredTextOutputSchema[OutputDataT]):
             Either the validated output data (left) or a retry message (right).
         """
         return await self.processor.process(
-            text, run_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
+            text, run_context, trace_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
         )
 
 
@@ -468,6 +545,7 @@ class PromptedOutputSchema(StructuredTextOutputSchema[OutputDataT]):
         self,
         text: str,
         run_context: RunContext[AgentDepsT],
+        trace_context: TraceContext,
         allow_partial: bool = False,
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
@@ -476,6 +554,7 @@ class PromptedOutputSchema(StructuredTextOutputSchema[OutputDataT]):
         Args:
             text: The output text to validate.
             run_context: The current run context.
+            trace_context: The trace context to use for tracing the output processing.
             allow_partial: If true, allow partial validation.
             wrap_validation_errors: If true, wrap the validation errors in a retry message.
 
@@ -485,7 +564,7 @@ class PromptedOutputSchema(StructuredTextOutputSchema[OutputDataT]):
         text = _utils.strip_markdown_fences(text)
 
         return await self.processor.process(
-            text, run_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
+            text, run_context, trace_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
         )
 
 
@@ -568,6 +647,7 @@ class BaseOutputProcessor(ABC, Generic[OutputDataT]):
         self,
         data: str,
         run_context: RunContext[AgentDepsT],
+        trace_context: TraceContext,
         allow_partial: bool = False,
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
@@ -637,6 +717,7 @@ class ObjectOutputProcessor(BaseOutputProcessor[OutputDataT]):
         self,
         data: str | dict[str, Any] | None,
         run_context: RunContext[AgentDepsT],
+        trace_context: TraceContext,
         allow_partial: bool = False,
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
@@ -645,6 +726,7 @@ class ObjectOutputProcessor(BaseOutputProcessor[OutputDataT]):
         Args:
             data: The output data to validate.
             run_context: The current run context.
+            trace_context: The trace context to use for tracing the output processing.
             allow_partial: If true, allow partial validation.
             wrap_validation_errors: If true, wrap the validation errors in a retry message.
 
@@ -664,14 +746,24 @@ class ObjectOutputProcessor(BaseOutputProcessor[OutputDataT]):
                 )
                 raise ToolRetryError(m) from e
             else:
-                raise  # pragma: lax no cover
+                raise
 
         if k := self.outer_typed_dict_key:
             output = output[k]
 
         if self._function_schema:
+            # Wraps the output function call in an OpenTelemetry span.
+            if trace_context.call:
+                call = trace_context.call
+                include_tool_call_id = True
+            else:
+                function_name = getattr(self._function_schema.function, '__name__', 'output_function')
+                call = _messages.ToolCallPart(tool_name=function_name, args=data)
+                include_tool_call_id = False
             try:
-                output = await self._function_schema.call(output, run_context)
+                output = await trace_context.execute_function_with_span(
+                    self._function_schema, run_context, output, call, include_tool_call_id
+                )
             except ModelRetry as r:
                 if wrap_validation_errors:
                     m = _messages.RetryPromptPart(
@@ -679,7 +771,7 @@ class ObjectOutputProcessor(BaseOutputProcessor[OutputDataT]):
                     )
                     raise ToolRetryError(m) from r
                 else:
-                    raise  # pragma: lax no cover
+                    raise
 
         return output
 
@@ -784,11 +876,12 @@ class UnionOutputProcessor(BaseOutputProcessor[OutputDataT]):
         self,
         data: str | dict[str, Any] | None,
         run_context: RunContext[AgentDepsT],
+        trace_context: TraceContext,
         allow_partial: bool = False,
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
         union_object = await self._union_processor.process(
-            data, run_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
+            data, run_context, trace_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
         )
 
         result = union_object.result
@@ -804,7 +897,7 @@ class UnionOutputProcessor(BaseOutputProcessor[OutputDataT]):
                 raise
 
         return await processor.process(
-            data, run_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
+            data, run_context, trace_context, allow_partial=allow_partial, wrap_validation_errors=wrap_validation_errors
         )
 
 
@@ -835,13 +928,20 @@ class PlainTextOutputProcessor(BaseOutputProcessor[OutputDataT]):
         self,
         data: str,
         run_context: RunContext[AgentDepsT],
+        trace_context: TraceContext,
         allow_partial: bool = False,
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
         args = {self._str_argument_name: data}
-
+        # Wraps the output function call in an OpenTelemetry span.
+        # Note: PlainTextOutputProcessor is used for text responses (not tool calls),
+        # so we don't have tool call attributes like gen_ai.tool.name or gen_ai.tool.call.id
+        function_name = getattr(self._function_schema.function, '__name__', 'text_output_function')
+        call = _messages.ToolCallPart(tool_name=function_name, args=args)
         try:
-            output = await self._function_schema.call(args, run_context)
+            output = await trace_context.execute_function_with_span(
+                self._function_schema, run_context, args, call, include_tool_call_id=False
+            )
         except ModelRetry as r:
             if wrap_validation_errors:
                 m = _messages.RetryPromptPart(
@@ -849,7 +949,7 @@ class PlainTextOutputProcessor(BaseOutputProcessor[OutputDataT]):
                 )
                 raise ToolRetryError(m) from r
             else:
-                raise  # pragma: lax no cover
+                raise  # pragma: no cover
 
         return cast(OutputDataT, output)
 
@@ -881,6 +981,7 @@ class OutputTool(Generic[OutputDataT]):
         self,
         tool_call: _messages.ToolCallPart,
         run_context: RunContext[AgentDepsT],
+        trace_context: TraceContext,
         allow_partial: bool = False,
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
@@ -889,6 +990,7 @@ class OutputTool(Generic[OutputDataT]):
         Args:
             tool_call: The tool call from the LLM to validate.
             run_context: The current run context.
+            trace_context: The trace context to use for tracing the output processing.
             allow_partial: If true, allow partial validation.
             wrap_validation_errors: If true, wrap the validation errors in a retry message.
 
@@ -897,7 +999,11 @@ class OutputTool(Generic[OutputDataT]):
         """
         try:
             output = await self.processor.process(
-                tool_call.args, run_context, allow_partial=allow_partial, wrap_validation_errors=False
+                tool_call.args,
+                run_context,
+                trace_context.with_call(tool_call),
+                allow_partial=allow_partial,
+                wrap_validation_errors=False,
             )
         except ValidationError as e:
             if wrap_validation_errors:
@@ -908,7 +1014,7 @@ class OutputTool(Generic[OutputDataT]):
                 )
                 raise ToolRetryError(m) from e
             else:
-                raise  # pragma: lax no cover
+                raise  # pragma: no cover
         except ModelRetry as r:
             if wrap_validation_errors:
                 m = _messages.RetryPromptPart(
@@ -918,7 +1024,7 @@ class OutputTool(Generic[OutputDataT]):
                 )
                 raise ToolRetryError(m) from r
             else:
-                raise  # pragma: lax no cover
+                raise  # pragma: no cover
         else:
             return output
 

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/agent.py

@@ -1089,6 +1089,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
                                 streamed_response,
                                 graph_ctx.deps.output_schema,
                                 _agent_graph.build_run_context(graph_ctx),
+                                _output.build_trace_context(graph_ctx),
                                 graph_ctx.deps.output_validators,
                                 final_result_details.tool_name,
                                 on_complete,

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/common_tools/duckduckgo.py

@@ -9,10 +9,13 @@ from typing_extensions import TypedDict
 from pydantic_ai.tools import Tool
 
 try:
-    from duckduckgo_search import DDGS
+    try:
+        from ddgs import DDGS
+    except ImportError:  # Fallback for older versions of ddgs
+        from duckduckgo_search import DDGS
 except ImportError as _import_error:
     raise ImportError(
-        'Please install `duckduckgo-search` to use the DuckDuckGo search tool, '
+        'Please install `ddgs` to use the DuckDuckGo search tool, '
         'you can use the `duckduckgo` optional group — `pip install "pydantic-ai-slim[duckduckgo]"`'
     ) from _import_error
 

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/exceptions.py

@@ -4,9 +4,9 @@ import json
 import sys
 
 if sys.version_info < (3, 11):
-    from exceptiongroup import ExceptionGroup  # pragma: lax no cover
+    from exceptiongroup import ExceptionGroup
 else:
-    ExceptionGroup = ExceptionGroup  # pragma: lax no cover
+    ExceptionGroup = ExceptionGroup
 
 __all__ = (
     'ModelRetry',

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/messages.py

@@ -411,9 +411,9 @@ class UserPromptPart:
     """Part type identifier, this is available on all parts as a discriminator."""
 
     def otel_event(self, settings: InstrumentationSettings) -> Event:
-        content: str | list[dict[str, Any] | str]
+        content: str | list[dict[str, Any] | str] | dict[str, Any]
         if isinstance(self.content, str):
-            content = self.content
+            content = self.content if settings.include_content else {'kind': 'text'}
         else:
             content = []
             for part in self.content:
@@ -433,7 +433,9 @@ class UserPromptPart:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-tool_return_ta: pydantic.TypeAdapter[Any] = pydantic.TypeAdapter(Any, config=pydantic.ConfigDict(defer_build=True))
+tool_return_ta: pydantic.TypeAdapter[Any] = pydantic.TypeAdapter(
+    Any, config=pydantic.ConfigDict(defer_build=True, ser_json_bytes='base64', val_json_bytes='base64')
+)
 
 
 @dataclass(repr=False)
@@ -743,7 +745,7 @@ class ModelResponse:
                         'type': 'function',  # TODO https://github.com/pydantic/pydantic-ai/issues/888
                         'function': {
                             'name': part.tool_name,
-                            'arguments': part.args,
+                            **({'arguments': part.args} if settings.include_content else {}),
                         },
                     }
                 )

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/models/__init__.py

@@ -227,6 +227,14 @@ KnownModelName = TypeAliasType(
         'heroku:claude-3-7-sonnet',
         'heroku:claude-4-sonnet',
         'heroku:claude-3-haiku',
+        'huggingface:Qwen/QwQ-32B',
+        'huggingface:Qwen/Qwen2.5-72B-Instruct',
+        'huggingface:Qwen/Qwen3-235B-A22B',
+        'huggingface:Qwen/Qwen3-32B',
+        'huggingface:deepseek-ai/DeepSeek-R1',
+        'huggingface:meta-llama/Llama-3.3-70B-Instruct',
+        'huggingface:meta-llama/Llama-4-Maverick-17B-128E-Instruct',
+        'huggingface:meta-llama/Llama-4-Scout-17B-16E-Instruct',
         'mistral:codestral-latest',
         'mistral:mistral-large-latest',
         'mistral:mistral-moderation-latest',
@@ -560,7 +568,7 @@ def override_allow_model_requests(allow_model_requests: bool) -> Iterator[None]:
         ALLOW_MODEL_REQUESTS = old_value  # pyright: ignore[reportConstantRedefinition]
 
 
-def infer_model(model: Model | KnownModelName | str) -> Model:
+def infer_model(model: Model | KnownModelName | str) -> Model:  # noqa: C901
     """Infer the model from the name."""
     if isinstance(model, Model):
         return model
@@ -624,6 +632,10 @@ def infer_model(model: Model | KnownModelName | str) -> Model:
         from .bedrock import BedrockConverseModel
 
         return BedrockConverseModel(model_name, provider=provider)
+    elif provider == 'huggingface':
+        from .huggingface import HuggingFaceModel
+
+        return HuggingFaceModel(model_name, provider=provider)
     else:
         raise UserError(f'Unknown model: {model}')  # pragma: no cover
 

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/models/anthropic.py

@@ -256,7 +256,7 @@ class AnthropicModel(Model):
         except APIStatusError as e:
             if (status_code := e.status_code) >= 400:
                 raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
-            raise  # pragma: lax no cover
+            raise  # pragma: no cover
 
     def _process_response(self, response: BetaMessage) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/models/bedrock.py

@@ -663,4 +663,4 @@ class _AsyncIteratorWrapper(Generic[T]):
             if type(e.__cause__) is StopIteration:
                 raise StopAsyncIteration
             else:
-                raise e  # pragma: lax no cover
+                raise e  # pragma: no cover

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/models/cohere.py

@@ -183,7 +183,7 @@ class CohereModel(Model):
         except ApiError as e:
             if (status_code := e.status_code) and status_code >= 400:
                 raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
-            raise  # pragma: lax no cover
+            raise  # pragma: no cover
 
     def _process_response(self, response: ChatResponse) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/models/gemini.py

@@ -253,7 +253,7 @@ class GeminiModel(Model):
 
         if gemini_labels := model_settings.get('gemini_labels'):
             if self._system == 'google-vertex':
-                request_data['labels'] = gemini_labels  # pragma: lax no cover
+                request_data['labels'] = gemini_labels
 
         headers = {'Content-Type': 'application/json', 'User-Agent': get_user_agent()}
         url = f'/{self._model_name}:{"streamGenerateContent" if streamed else "generateContent"}'
@@ -415,7 +415,7 @@ def _settings_to_generation_config(model_settings: GeminiModelSettings) -> _Gemi
     if (frequency_penalty := model_settings.get('frequency_penalty')) is not None:
         config['frequency_penalty'] = frequency_penalty
     if (thinkingConfig := model_settings.get('gemini_thinking_config')) is not None:
-        config['thinking_config'] = thinkingConfig  # pragma: lax no cover
+        config['thinking_config'] = thinkingConfig
     return config
 
 

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/models/google.py

@@ -166,7 +166,7 @@ class GoogleModel(Model):
         self._model_name = model_name
 
         if isinstance(provider, str):
-            provider = GoogleProvider(vertexai=provider == 'google-vertex')  # pragma: lax no cover
+            provider = GoogleProvider(vertexai=provider == 'google-vertex')
 
         self._provider = provider
         self._system = provider.name

{pydantic_ai_slim-0.4.2 → pydantic_ai_slim-0.4.3}/pydantic_ai/models/groq.py

@@ -248,7 +248,7 @@ class GroqModel(Model):
         except APIStatusError as e:
             if (status_code := e.status_code) >= 400:
                 raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
-            raise  # pragma: lax no cover
+            raise  # pragma: no cover
 
     def _process_response(self, response: chat.ChatCompletion) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""