pydantic-ai-slim 0.1.1__tar.gz → 0.1.3__tar.gz

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.1.1
+Version: 0.1.3
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,7 +29,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.1.1
+Requires-Dist: pydantic-graph==0.1.3
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic
@@ -45,13 +45,13 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.1.1; extra == 'evals'
+Requires-Dist: pydantic-evals==0.1.3; extra == 'evals'
 Provides-Extra: groq
 Requires-Dist: groq>=0.15.0; extra == 'groq'
 Provides-Extra: logfire
 Requires-Dist: logfire>=3.11.0; extra == 'logfire'
 Provides-Extra: mcp
-Requires-Dist: mcp>=1.4.1; (python_version >= '3.10') and extra == 'mcp'
+Requires-Dist: mcp>=1.5.0; (python_version >= '3.10') and extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/_agent_graph.py

@@ -427,6 +427,18 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                     # No events are emitted during the handling of text responses, so we don't need to yield anything
                     self._next_node = await self._handle_text_response(ctx, texts)
                 else:
+                    # we've got an empty response, this sometimes happens with anthropic (and perhaps other models)
+                    # when the model has already returned text along side tool calls
+                    # in this scenario, if text responses are allowed, we return text from the most recent model
+                    # response, if any
+                    if allow_text_output(ctx.deps.output_schema):
+                        for message in reversed(ctx.state.message_history):
+                            if isinstance(message, _messages.ModelResponse):
+                                last_texts = [p.content for p in message.parts if isinstance(p, _messages.TextPart)]
+                                if last_texts:
+                                    self._next_node = await self._handle_text_response(ctx, last_texts)
+                                    return
+
                     raise exceptions.UnexpectedModelBehavior('Received empty model response')
 
             self._events_iterator = _run_stream()
@@ -530,6 +542,7 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
 
         text = '\n\n'.join(texts)
         if allow_text_output(output_schema):
+            # The following cast is safe because we know `str` is an allowed result type
             result_data_input = cast(NodeRunEndT, text)
             try:
                 result_data = await _validate_output(result_data_input, ctx, None)
@@ -537,7 +550,6 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                 ctx.state.increment_retries(ctx.deps.max_result_retries)
                 return ModelRequestNode[DepsT, NodeRunEndT](_messages.ModelRequest(parts=[e.tool_retry]))
             else:
-                # The following cast is safe because we know `str` is an allowed result type
                 return self._handle_final_result(ctx, result.FinalResult(result_data, None, None), [])
         else:
             ctx.state.increment_retries(ctx.deps.max_result_retries)

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/agent.py

@@ -659,7 +659,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             start_node,
             state=state,
             deps=graph_deps,
-            span=use_span(run_span, end_on_exit=True),
+            span=use_span(run_span, end_on_exit=True) if run_span.is_recording() else None,
             infer_name=False,
         ) as graph_run:
             yield AgentRun(graph_run)

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/common_tools/duckduckgo.py

@@ -54,8 +54,6 @@ class DuckDuckGoSearchTool:
         """
         search = functools.partial(self.client.text, max_results=self.max_results)
         results = await anyio.to_thread.run_sync(search, query)
-        if len(results) == 0:
-            raise RuntimeError('No search results found.')
         return duckduckgo_ta.validate_python(results)
 
 

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/common_tools/tavily.py

@@ -63,8 +63,6 @@ class TavilySearchTool:
             The search results.
         """
         results = await self.client.search(query, search_depth=search_deep, topic=topic, time_range=time_range)  # type: ignore[reportUnknownMemberType]
-        if not results['results']:
-            raise RuntimeError('No search results found.')
         return tavily_search_ta.validate_python(results['results'])
 
 

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/mcp.py

@@ -4,6 +4,7 @@ from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Sequence
 from contextlib import AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
+from pathlib import Path
 from types import TracebackType
 from typing import Any
 
@@ -150,13 +151,16 @@ class MCPServerStdio(MCPServer):
     If you want to inherit the environment variables from the parent process, use `env=os.environ`.
     """
 
+    cwd: str | Path | None = None
+    """The working directory to use when spawning the process."""
+
     @asynccontextmanager
     async def client_streams(
         self,
     ) -> AsyncIterator[
         tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]
     ]:
-        server = StdioServerParameters(command=self.command, args=list(self.args), env=self.env)
+        server = StdioServerParameters(command=self.command, args=list(self.args), env=self.env, cwd=self.cwd)
         async with stdio_client(server=server) as (read_stream, write_stream):
             yield read_stream, write_stream
 

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/messages.py

@@ -508,6 +508,8 @@ class ToolCallPart:
         """
         if isinstance(self.args, dict):
             return self.args
+        if isinstance(self.args, str) and not self.args:
+            return {}
         args = pydantic_core.from_json(self.args)
         assert isinstance(args, dict), 'args should be a dict'
         return cast(dict[str, Any], args)
@@ -589,7 +591,7 @@ ModelMessage = Annotated[Union[ModelRequest, ModelResponse], pydantic.Discrimina
 """Any message sent to or returned by a model."""
 
 ModelMessagesTypeAdapter = pydantic.TypeAdapter(
-    list[ModelMessage], config=pydantic.ConfigDict(defer_build=True, ser_json_bytes='base64')
+    list[ModelMessage], config=pydantic.ConfigDict(defer_build=True, ser_json_bytes='base64', val_json_bytes='base64')
 )
 """Pydantic [`TypeAdapter`][pydantic.type_adapter.TypeAdapter] for (de)serializing messages."""
 

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/models/__init__.py

@@ -106,6 +106,7 @@ KnownModelName = TypeAliasType(
         'google-gla:gemini-2.0-flash',
         'google-gla:gemini-2.0-flash-lite-preview-02-05',
         'google-gla:gemini-2.0-pro-exp-02-05',
+        'google-gla:gemini-2.5-flash-preview-04-17',
         'google-gla:gemini-2.5-pro-exp-03-25',
         'google-gla:gemini-2.5-pro-preview-03-25',
         'google-vertex:gemini-1.0-pro',
@@ -118,6 +119,7 @@ KnownModelName = TypeAliasType(
         'google-vertex:gemini-2.0-flash',
         'google-vertex:gemini-2.0-flash-lite-preview-02-05',
         'google-vertex:gemini-2.0-pro-exp-02-05',
+        'google-vertex:gemini-2.5-flash-preview-04-17',
         'google-vertex:gemini-2.5-pro-exp-03-25',
         'google-vertex:gemini-2.5-pro-preview-03-25',
         'gpt-3.5-turbo',

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/models/anthropic.py

@@ -239,6 +239,7 @@ class AnthropicModel(Model):
                 timeout=model_settings.get('timeout', NOT_GIVEN),
                 metadata=model_settings.get('anthropic_metadata', NOT_GIVEN),
                 extra_headers={'User-Agent': get_user_agent()},
+                extra_body=model_settings.get('extra_body'),
             )
         except APIStatusError as e:
             if (status_code := e.status_code) >= 400:

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/models/bedrock.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import functools
 import typing
-from collections.abc import AsyncIterator, Iterable, Mapping
+from collections.abc import AsyncIterator, Iterable, Iterator, Mapping
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime
+from itertools import count
 from typing import TYPE_CHECKING, Any, Generic, Literal, Union, cast, overload
 
 import anyio
@@ -369,13 +370,14 @@ class BedrockConverseModel(Model):
         """Just maps a `pydantic_ai.Message` to the Bedrock `MessageUnionTypeDef`."""
         system_prompt: list[SystemContentBlockTypeDef] = []
         bedrock_messages: list[MessageUnionTypeDef] = []
+        document_count: Iterator[int] = count(1)
         for m in messages:
             if isinstance(m, ModelRequest):
                 for part in m.parts:
                     if isinstance(part, SystemPromptPart):
                         system_prompt.append({'text': part.content})
                     elif isinstance(part, UserPromptPart):
-                        bedrock_messages.extend(await self._map_user_prompt(part))
+                        bedrock_messages.extend(await self._map_user_prompt(part, document_count))
                     elif isinstance(part, ToolReturnPart):
                         assert part.tool_call_id is not None
                         bedrock_messages.append(
@@ -430,20 +432,18 @@ class BedrockConverseModel(Model):
         return system_prompt, bedrock_messages
 
     @staticmethod
-    async def _map_user_prompt(part: UserPromptPart) -> list[MessageUnionTypeDef]:
+    async def _map_user_prompt(part: UserPromptPart, document_count: Iterator[int]) -> list[MessageUnionTypeDef]:
         content: list[ContentBlockUnionTypeDef] = []
         if isinstance(part.content, str):
             content.append({'text': part.content})
         else:
-            document_count = 0
             for item in part.content:
                 if isinstance(item, str):
                     content.append({'text': item})
                 elif isinstance(item, BinaryContent):
                     format = item.format
                     if item.is_document:
-                        document_count += 1
-                        name = f'Document {document_count}'
+                        name = f'Document {next(document_count)}'
                         assert format in ('pdf', 'txt', 'csv', 'doc', 'docx', 'xls', 'xlsx', 'html', 'md')
                         content.append({'document': {'name': name, 'format': format, 'source': {'bytes': item.data}}})
                     elif item.is_image:
@@ -464,8 +464,7 @@ class BedrockConverseModel(Model):
                         content.append({'image': image})
 
                     elif item.kind == 'document-url':
-                        document_count += 1
-                        name = f'Document {document_count}'
+                        name = f'Document {next(document_count)}'
                         data = response.content
                         content.append({'document': {'name': name, 'format': item.format, 'source': {'bytes': data}}})
 

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/models/gemini.py

@@ -58,6 +58,7 @@ LatestGeminiModelNames = Literal[
     'gemini-2.0-flash',
     'gemini-2.0-flash-lite-preview-02-05',
     'gemini-2.0-pro-exp-02-05',
+    'gemini-2.5-flash-preview-04-17',
     'gemini-2.5-pro-exp-03-25',
     'gemini-2.5-pro-preview-03-25',
 ]

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/models/groq.py

@@ -218,6 +218,7 @@ class GroqModel(Model):
                 frequency_penalty=model_settings.get('frequency_penalty', NOT_GIVEN),
                 logit_bias=model_settings.get('logit_bias', NOT_GIVEN),
                 extra_headers={'User-Agent': get_user_agent()},
+                extra_body=model_settings.get('extra_body'),
             )
         except APIStatusError as e:
             if (status_code := e.status_code) >= 400:

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/models/instrumented.py

@@ -261,9 +261,11 @@ class InstrumentedModel(WrapperModel):
     @staticmethod
     def messages_to_otel_events(messages: list[ModelMessage]) -> list[Event]:
         events: list[Event] = []
+        last_model_request: ModelRequest | None = None
         for message_index, message in enumerate(messages):
             message_events: list[Event] = []
             if isinstance(message, ModelRequest):
+                last_model_request = message
                 for part in message.parts:
                     if hasattr(part, 'otel_event'):
                         message_events.append(part.otel_event())
@@ -275,6 +277,10 @@ class InstrumentedModel(WrapperModel):
                     **(event.attributes or {}),
                 }
             events.extend(message_events)
+        if last_model_request and last_model_request.instructions:
+            events.insert(
+                0, Event('gen_ai.system.message', body={'content': last_model_request.instructions, 'role': 'system'})
+            )
         for event in events:
             event.body = InstrumentedModel.serialize_any(event.body)
         return events

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/models/openai.py

@@ -1,6 +1,7 @@
 from __future__ import annotations as _annotations
 
 import base64
+import re
 import warnings
 from collections.abc import AsyncIterable, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
@@ -283,6 +284,7 @@ class OpenAIModel(Model):
                 reasoning_effort=model_settings.get('openai_reasoning_effort', NOT_GIVEN),
                 user=model_settings.get('openai_user', NOT_GIVEN),
                 extra_headers={'User-Agent': get_user_agent()},
+                extra_body=model_settings.get('extra_body'),
             )
         except APIStatusError as e:
             if (status_code := e.status_code) >= 400:
@@ -622,6 +624,7 @@ class OpenAIResponsesModel(Model):
                 reasoning=reasoning,
                 user=model_settings.get('openai_user', NOT_GIVEN),
                 extra_headers={'User-Agent': get_user_agent()},
+                extra_body=model_settings.get('extra_body'),
             )
         except APIStatusError as e:
             if (status_code := e.status_code) >= 400:
@@ -932,6 +935,31 @@ def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk | responses.R
         )
 
 
+_STRICT_INCOMPATIBLE_KEYS = [
+    'minLength',
+    'maxLength',
+    'pattern',
+    'format',
+    'minimum',
+    'maximum',
+    'multipleOf',
+    'patternProperties',
+    'unevaluatedProperties',
+    'propertyNames',
+    'minProperties',
+    'maxProperties',
+    'unevaluatedItems',
+    'contains',
+    'minContains',
+    'maxContains',
+    'minItems',
+    'maxItems',
+    'uniqueItems',
+]
+
+_sentinel = object()
+
+
 @dataclass
 class _OpenAIJsonSchema(WalkJsonSchema):
     """Recursively handle the schema to make it compatible with OpenAI strict mode.
@@ -946,28 +974,64 @@ class _OpenAIJsonSchema(WalkJsonSchema):
         super().__init__(schema)
         self.strict = strict
         self.is_strict_compatible = True
+        self.root_ref = schema.get('$ref')
+
+    def walk(self) -> JsonSchema:
+        # Note: OpenAI does not support anyOf at the root in strict mode
+        # However, we don't need to check for it here because we ensure in pydantic_ai._utils.check_object_json_schema
+        # that the root schema either has type 'object' or is recursive.
+        result = super().walk()
+
+        # For recursive models, we need to tweak the schema to make it compatible with strict mode.
+        # Because the following should never change the semantics of the schema we apply it unconditionally.
+        if self.root_ref is not None:
+            result.pop('$ref', None)  # We replace references to the self.root_ref with just '#' in the transform method
+            root_key = re.sub(r'^#/\$defs/', '', self.root_ref)
+            result.update(self.defs.get(root_key) or {})
+
+        return result
 
-    def transform(self, schema: JsonSchema) -> JsonSchema:
+    def transform(self, schema: JsonSchema) -> JsonSchema:  # noqa C901
         # Remove unnecessary keys
         schema.pop('title', None)
         schema.pop('default', None)
         schema.pop('$schema', None)
         schema.pop('discriminator', None)
 
-        # Remove incompatible keys, but note their impact in the description provided to the LLM
+        if schema_ref := schema.get('$ref'):
+            if schema_ref == self.root_ref:
+                schema['$ref'] = '#'
+            if len(schema) > 1:
+                # OpenAI Strict mode doesn't support siblings to "$ref", but _does_ allow siblings to "anyOf".
+                # So if there is a "description" field or any other extra info, we move the "$ref" into an "anyOf":
+                schema['anyOf'] = [{'$ref': schema.pop('$ref')}]
+
+        # Track strict-incompatible keys
+        incompatible_values: dict[str, Any] = {}
+        for key in _STRICT_INCOMPATIBLE_KEYS:
+            value = schema.get(key, _sentinel)
+            if value is not _sentinel:
+                incompatible_values[key] = value
         description = schema.get('description')
-        min_length = schema.pop('minLength', None)
-        max_length = schema.pop('minLength', None)
-        if description is not None:
-            notes = list[str]()
-            if min_length is not None:  # pragma: no cover
-                notes.append(f'min_length={min_length}')
-            if max_length is not None:  # pragma: no cover
-                notes.append(f'max_length={max_length}')
-            if notes:  # pragma: no cover
-                schema['description'] = f'{description} ({", ".join(notes)})'
+        if incompatible_values:
+            if self.strict is True:
+                notes: list[str] = []
+                for key, value in incompatible_values.items():
+                    schema.pop(key)
+                    notes.append(f'{key}={value}')
+                notes_string = ', '.join(notes)
+                schema['description'] = notes_string if not description else f'{description} ({notes_string})'
+            elif self.strict is None:
+                self.is_strict_compatible = False
 
         schema_type = schema.get('type')
+        if 'oneOf' in schema:
+            # OpenAI does not support oneOf in strict mode
+            if self.strict is True:
+                schema['anyOf'] = schema.pop('oneOf')
+            else:
+                self.is_strict_compatible = False
+
         if schema_type == 'object':
             if self.strict is True:
                 # additional properties are disallowed

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pydantic_ai/settings.py

@@ -141,6 +141,16 @@ class ModelSettings(TypedDict, total=False):
     * Cohere
     """
 
+    extra_body: object
+    """Extra body to send to the model.
+
+    Supported by:
+
+    * OpenAI
+    * Anthropic
+    * Groq
+    """
+
 
 def merge_model_settings(base: ModelSettings | None, overrides: ModelSettings | None) -> ModelSettings | None:
     """Merge two sets of model settings, preferring the overrides.

{pydantic_ai_slim-0.1.1 → pydantic_ai_slim-0.1.3}/pyproject.toml

@@ -69,7 +69,7 @@ tavily = ["tavily-python>=0.5.0"]
 # CLI
 cli = ["rich>=13", "prompt-toolkit>=3", "argcomplete>=3.5.0"]
 # MCP
-mcp = ["mcp>=1.4.1; python_version >= '3.10'"]
+mcp = ["mcp>=1.5.0; python_version >= '3.10'"]
 # Evals
 evals = ["pydantic-evals=={{ version }}"]