pydantic-ai-slim 0.0.31__tar.gz → 0.0.32__tar.gz

{pydantic_ai_slim-0.0.31 → pydantic_ai_slim-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.31
+Version: 0.0.32
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -28,12 +28,11 @@ Requires-Dist: eval-type-backport>=0.2.0
 Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
-Requires-Dist: logfire-api>=1.2.0
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.0.31
+Requires-Dist: pydantic-graph==0.0.32
 Requires-Dist: pydantic>=2.10
 Provides-Extra: anthropic
-Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'
+Requires-Dist: anthropic>=0.49.0; extra == 'anthropic'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.13.11; extra == 'cohere'
 Provides-Extra: duckduckgo

{pydantic_ai_slim-0.0.31 → pydantic_ai_slim-0.0.32}/pydantic_ai/_agent_graph.py

@@ -2,13 +2,14 @@ from __future__ import annotations as _annotations
 
 import asyncio
 import dataclasses
+import json
 from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager, contextmanager
 from contextvars import ContextVar
 from dataclasses import field
 from typing import Any, Generic, Literal, Union, cast
 
-import logfire_api
+from opentelemetry.trace import Span, Tracer
 from typing_extensions import TypeGuard, TypeVar, assert_never
 
 from pydantic_graph import BaseNode, Graph, GraphRunContext
@@ -42,17 +43,6 @@ __all__ = (
     'capture_run_messages',
 )
 
-_logfire = logfire_api.Logfire(otel_scope='pydantic-ai')
-
-# while waiting for https://github.com/pydantic/logfire/issues/745
-try:
-    import logfire._internal.stack_info
-except ImportError:
-    pass
-else:
-    from pathlib import Path
-
-    logfire._internal.stack_info.NON_USER_CODE_PREFIXES += (str(Path(__file__).parent.absolute()),)
 
 T = TypeVar('T')
 S = TypeVar('S')
@@ -105,7 +95,8 @@ class GraphAgentDeps(Generic[DepsT, ResultDataT]):
 
     function_tools: dict[str, Tool[DepsT]] = dataclasses.field(repr=False)
 
-    run_span: logfire_api.LogfireSpan
+    run_span: Span
+    tracer: Tracer
 
 
 class AgentNode(BaseNode[GraphAgentState, GraphAgentDeps[DepsT, Any], result.FinalResult[NodeRunEndT]]):
@@ -330,7 +321,9 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
         ctx.state.run_step += 1
 
         model_settings = merge_model_settings(ctx.deps.model_settings, None)
-        with _logfire.span('preparing model request params {run_step=}', run_step=ctx.state.run_step):
+        with ctx.deps.tracer.start_as_current_span(
+            'preparing model request params', attributes=dict(run_step=ctx.state.run_step)
+        ):
             model_request_parameters = await _prepare_request_parameters(ctx)
         return model_settings, model_request_parameters
 
@@ -380,26 +373,12 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         self, ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]]
     ) -> AsyncIterator[AsyncIterator[_messages.HandleResponseEvent]]:
         """Process the model response and yield events for the start and end of each function tool call."""
-        with _logfire.span('handle model response', run_step=ctx.state.run_step) as handle_span:
-            stream = self._run_stream(ctx)
-            yield stream
+        stream = self._run_stream(ctx)
+        yield stream
 
-            # Run the stream to completion if it was not finished:
-            async for _event in stream:
-                pass
-
-            # Set the next node based on the final state of the stream
-            next_node = self._next_node
-            if isinstance(next_node, End):
-                handle_span.set_attribute('result', next_node.data)
-                handle_span.message = 'handle model response -> final result'
-            elif tool_responses := self._tool_responses:
-                # TODO: We could drop `self._tool_responses` if we drop this set_attribute
-                #   I'm thinking it might be better to just create a span for the handling of each tool
-                #   than to set an attribute here.
-                handle_span.set_attribute('tool_responses', tool_responses)
-                tool_responses_str = ' '.join(r.part_kind for r in tool_responses)
-                handle_span.message = f'handle model response -> {tool_responses_str}'
+        # Run the stream to completion if it was not finished:
+        async for _event in stream:
+            pass
 
     async def _run_stream(
         self, ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]]
@@ -494,10 +473,29 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         if tool_responses:
             messages.append(_messages.ModelRequest(parts=tool_responses))
 
-        run_span.set_attribute('usage', usage)
-        run_span.set_attribute(
-            'all_messages_events',
-            [InstrumentedModel.event_to_dict(e) for e in InstrumentedModel.messages_to_otel_events(messages)],
+        run_span.set_attributes(
+            {
+                **usage.opentelemetry_attributes(),
+                'all_messages_events': json.dumps(
+                    [InstrumentedModel.event_to_dict(e) for e in InstrumentedModel.messages_to_otel_events(messages)]
+                ),
+                'final_result': final_result.data
+                if isinstance(final_result.data, str)
+                else json.dumps(InstrumentedModel.serialize_any(final_result.data)),
+            }
+        )
+        run_span.set_attributes(
+            {
+                'logfire.json_schema': json.dumps(
+                    {
+                        'type': 'object',
+                        'properties': {
+                            'all_messages_events': {'type': 'array'},
+                            'final_result': {'type': 'object'},
+                        },
+                    }
+                ),
+            }
         )
 
         # End the run with self.data
@@ -619,7 +617,10 @@ async def process_function_tools(
 
     # Run all tool tasks in parallel
     results_by_index: dict[int, _messages.ModelRequestPart] = {}
-    with _logfire.span('running {tools=}', tools=[call.tool_name for _, call in calls_to_run]):
+    tool_names = [call.tool_name for _, call in calls_to_run]
+    with ctx.deps.tracer.start_as_current_span(
+        'running tools', attributes={'tools': tool_names, 'logfire.msg': f'running tools: {", ".join(tool_names)}'}
+    ):
         # TODO: Should we wrap each individual tool call in a dedicated span?
         tasks = [asyncio.create_task(tool.run(call, run_context), name=call.tool_name) for tool, call in calls_to_run]
         pending = tasks

{pydantic_ai_slim-0.0.31 → pydantic_ai_slim-0.0.32}/pydantic_ai/agent.py

@@ -8,7 +8,7 @@ from copy import deepcopy
 from types import FrameType
 from typing import Any, Callable, Generic, cast, final, overload
 
-import logfire_api
+from opentelemetry.trace import NoOpTracer, use_span
 from typing_extensions import TypeGuard, TypeVar, deprecated
 
 from pydantic_graph import End, Graph, GraphRun, GraphRunContext
@@ -58,17 +58,6 @@ __all__ = (
     'UserPromptNode',
 )
 
-_logfire = logfire_api.Logfire(otel_scope='pydantic-ai')
-
-# while waiting for https://github.com/pydantic/logfire/issues/745
-try:
-    import logfire._internal.stack_info
-except ImportError:
-    pass
-else:
-    from pathlib import Path
-
-    logfire._internal.stack_info.NON_USER_CODE_PREFIXES += (str(Path(__file__).parent.absolute()),)
 
 T = TypeVar('T')
 S = TypeVar('S')
@@ -123,6 +112,9 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
     The type of the result data, used to validate the result data, defaults to `str`.
     """
 
+    instrument: bool
+    """Automatically instrument with OpenTelemetry. Will use Logfire if it's configured."""
+
     _deps_type: type[AgentDepsT] = dataclasses.field(repr=False)
     _result_tool_name: str = dataclasses.field(repr=False)
     _result_tool_description: str | None = dataclasses.field(repr=False)
@@ -155,6 +147,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         tools: Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] = (),
         defer_model_check: bool = False,
         end_strategy: EndStrategy = 'early',
+        instrument: bool = False,
     ):
         """Create an agent.
 
@@ -184,6 +177,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                 [override the model][pydantic_ai.Agent.override] for testing.
             end_strategy: Strategy for handling tool calls that are requested alongside a final result.
                 See [`EndStrategy`][pydantic_ai.agent.EndStrategy] for more information.
+            instrument: Automatically instrument with OpenTelemetry. Will use Logfire if it's configured.
         """
         if model is None or defer_model_check:
             self.model = model
@@ -194,6 +188,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         self.name = name
         self.model_settings = model_settings
         self.result_type = result_type
+        self.instrument = instrument
 
         self._deps_type = deps_type
 
@@ -396,6 +391,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         if infer_name and self.name is None:
             self._infer_name(inspect.currentframe())
         model_used = self._get_model(model)
+        del model
 
         deps = self._get_deps(deps)
         new_message_index = len(message_history) if message_history else 0
@@ -425,14 +421,20 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         model_settings = merge_model_settings(self.model_settings, model_settings)
         usage_limits = usage_limits or _usage.UsageLimits()
 
-        # Build the deps object for the graph
-        run_span = _logfire.span(
-            '{agent_name} run {prompt=}',
-            prompt=user_prompt,
-            agent=self,
-            model_name=model_used.model_name if model_used else 'no-model',
-            agent_name=self.name or 'agent',
+        if isinstance(model_used, InstrumentedModel):
+            tracer = model_used.tracer
+        else:
+            tracer = NoOpTracer()
+        agent_name = self.name or 'agent'
+        run_span = tracer.start_span(
+            'agent run',
+            attributes={
+                'model_name': model_used.model_name if model_used else 'no-model',
+                'agent_name': agent_name,
+                'logfire.msg': f'{agent_name} run',
+            },
         )
+
         graph_deps = _agent_graph.GraphAgentDeps[AgentDepsT, RunResultDataT](
             user_deps=deps,
             prompt=user_prompt,
@@ -447,6 +449,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
             result_validators=result_validators,
             function_tools=self._function_tools,
             run_span=run_span,
+            tracer=tracer,
         )
         start_node = _agent_graph.UserPromptNode[AgentDepsT](
             user_prompt=user_prompt,
@@ -460,7 +463,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
             state=state,
             deps=graph_deps,
             infer_name=False,
-            span=run_span,
+            span=use_span(run_span, end_on_exit=True),
         ) as graph_run:
             yield AgentRun(graph_run)
 
@@ -1116,7 +1119,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         else:
             raise exceptions.UserError('`model` must be set either when creating the agent or when calling it.')
 
-        if not isinstance(model_, InstrumentedModel):
+        if self.instrument and not isinstance(model_, InstrumentedModel):
             model_ = InstrumentedModel(model_)
 
         return model_

{pydantic_ai_slim-0.0.31 → pydantic_ai_slim-0.0.32}/pydantic_ai/models/__init__.py

@@ -28,9 +28,11 @@ if TYPE_CHECKING:
 
 
 KnownModelName = Literal[
+    'anthropic:claude-3-7-sonnet-latest',
     'anthropic:claude-3-5-haiku-latest',
     'anthropic:claude-3-5-sonnet-latest',
     'anthropic:claude-3-opus-latest',
+    'claude-3-7-sonnet-latest',
     'claude-3-5-haiku-latest',
     'claude-3-5-sonnet-latest',
     'claude-3-opus-latest',
@@ -56,6 +58,7 @@ KnownModelName = Literal[
     'google-gla:gemini-exp-1206',
     '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-vertex:gemini-1.0-pro',
     'google-vertex:gemini-1.5-flash',
     'google-vertex:gemini-1.5-flash-8b',
@@ -65,6 +68,7 @@ KnownModelName = Literal[
     'google-vertex:gemini-exp-1206',
     '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',
     'gpt-3.5-turbo',
     'gpt-3.5-turbo-0125',
     'gpt-3.5-turbo-0301',

{pydantic_ai_slim-0.0.31 → pydantic_ai_slim-0.0.32}/pydantic_ai/models/anthropic.py

@@ -42,6 +42,7 @@ from . import (
 try:
     from anthropic import NOT_GIVEN, APIStatusError, AsyncAnthropic, AsyncStream
     from anthropic.types import (
+        ContentBlock,
         ImageBlockParam,
         Message as AnthropicMessage,
         MessageParam,
@@ -69,6 +70,7 @@ except ImportError as _import_error:
     ) from _import_error
 
 LatestAnthropicModelNames = Literal[
+    'claude-3-7-sonnet-latest',
     'claude-3-5-haiku-latest',
     'claude-3-5-sonnet-latest',
     'claude-3-opus-latest',
@@ -423,7 +425,7 @@ class AnthropicStreamedResponse(StreamedResponse):
     _timestamp: datetime
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
-        current_block: TextBlock | ToolUseBlock | None = None
+        current_block: ContentBlock | None = None
         current_json: str = ''
 
         async for event in self._response:

{pydantic_ai_slim-0.0.31 → pydantic_ai_slim-0.0.32}/pydantic_ai/models/gemini.py

@@ -53,6 +53,7 @@ LatestGeminiModelNames = Literal[
     'gemini-exp-1206',
     'gemini-2.0-flash',
     'gemini-2.0-flash-lite-preview-02-05',
+    'gemini-2.0-pro-exp-02-05',
 ]
 """Latest Gemini models."""
 

{pydantic_ai_slim-0.0.31 → pydantic_ai_slim-0.0.32}/pydantic_ai/models/instrumented.py

@@ -6,7 +6,6 @@ from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
 from typing import Any, Callable, Literal
 
-import logfire_api
 from opentelemetry._events import Event, EventLogger, EventLoggerProvider, get_event_logger_provider
 from opentelemetry.trace import Span, Tracer, TracerProvider, get_tracer_provider
 from opentelemetry.util.types import AttributeValue
@@ -59,27 +58,15 @@ class InstrumentedModel(WrapperModel):
         event_logger_provider: EventLoggerProvider | None = None,
         event_mode: Literal['attributes', 'logs'] = 'attributes',
     ):
+        from pydantic_ai import __version__
+
         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')
+        self.tracer = tracer_provider.get_tracer('pydantic-ai', __version__)
+        self.event_logger = event_logger_provider.get_event_logger('pydantic-ai', __version__)
         self.event_mode = event_mode
 
-    @classmethod
-    def from_logfire(
-        cls,
-        wrapped: Model | KnownModelName,
-        logfire_instance: logfire_api.Logfire = logfire_api.DEFAULT_LOGFIRE_INSTANCE,
-        event_mode: Literal['attributes', 'logs'] = 'attributes',
-    ) -> 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, event_mode)
-
     async def request(
         self,
         messages: list[ModelMessage],
@@ -199,19 +186,30 @@ class InstrumentedModel(WrapperModel):
     @staticmethod
     def messages_to_otel_events(messages: list[ModelMessage]) -> list[Event]:
         result: list[Event] = []
-        for message in messages:
+        for message_index, message in enumerate(messages):
+            message_events: list[Event] = []
             if isinstance(message, ModelRequest):
                 for part in message.parts:
                     if hasattr(part, 'otel_event'):
-                        result.append(part.otel_event())
+                        message_events.append(part.otel_event())
             elif isinstance(message, ModelResponse):
-                result.extend(message.otel_events())
+                message_events = message.otel_events()
+            for event in message_events:
+                event.attributes = {
+                    'gen_ai.message.index': message_index,
+                    **(event.attributes or {}),
+                }
+            result.extend(message_events)
         for event in result:
-            try:
-                event.body = ANY_ADAPTER.dump_python(event.body, mode='json')
-            except Exception:
-                try:
-                    event.body = str(event.body)
-                except Exception:
-                    event.body = 'Unable to serialize event body'
+            event.body = InstrumentedModel.serialize_any(event.body)
         return result
+
+    @staticmethod
+    def serialize_any(value: Any) -> str:
+        try:
+            return ANY_ADAPTER.dump_python(value, mode='json')
+        except Exception:
+            try:
+                return str(value)
+            except Exception as e:
+                return f'Unable to serialize: {e}'

{pydantic_ai_slim-0.0.31 → pydantic_ai_slim-0.0.32}/pydantic_ai/result.py

@@ -6,7 +6,6 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Generic, Union, cast
 
-import logfire_api
 from typing_extensions import TypeVar, assert_type
 
 from . import _result, _utils, exceptions, messages as _messages, models
@@ -49,8 +48,6 @@ A function that always takes and returns the same type of data (which is the res
 Usage `ResultValidatorFunc[AgentDepsT, T]`.
 """
 
-_logfire = logfire_api.Logfire(otel_scope='pydantic-ai')
-
 
 @dataclass
 class AgentStream(Generic[AgentDepsT, ResultDataT]):
@@ -302,17 +299,14 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
         if self._result_schema and not self._result_schema.allow_text_result:
             raise exceptions.UserError('stream_text() can only be used with text responses')
 
-        with _logfire.span('response stream text') as lf_span:
-            if delta:
-                async for text in self._stream_response_text(delta=delta, debounce_by=debounce_by):
-                    yield text
-            else:
-                combined_validated_text = ''
-                async for text in self._stream_response_text(delta=delta, debounce_by=debounce_by):
-                    combined_validated_text = await self._validate_text_result(text)
-                    yield combined_validated_text
-                lf_span.set_attribute('combined_text', combined_validated_text)
-            await self._marked_completed(self._stream_response.get())
+        if delta:
+            async for text in self._stream_response_text(delta=delta, debounce_by=debounce_by):
+                yield text
+        else:
+            async for text in self._stream_response_text(delta=delta, debounce_by=debounce_by):
+                combined_validated_text = await self._validate_text_result(text)
+                yield combined_validated_text
+        await self._marked_completed(self._stream_response.get())
 
     async def stream_structured(
         self, *, debounce_by: float | None = 0.1
@@ -327,22 +321,20 @@ class StreamedRunResult(Generic[AgentDepsT, ResultDataT]):
         Returns:
             An async iterable of the structured response message and whether that is the last message.
         """
-        with _logfire.span('response stream structured') as lf_span:
-            # if the message currently has any parts with content, yield before streaming
-            msg = self._stream_response.get()
-            for part in msg.parts:
-                if part.has_content():
-                    yield msg, False
-                    break
-
-            async for msg in self._stream_response_structured(debounce_by=debounce_by):
+        # if the message currently has any parts with content, yield before streaming
+        msg = self._stream_response.get()
+        for part in msg.parts:
+            if part.has_content():
                 yield msg, False
+                break
 
-            msg = self._stream_response.get()
-            yield msg, True
+        async for msg in self._stream_response_structured(debounce_by=debounce_by):
+            yield msg, False
+
+        msg = self._stream_response.get()
+        yield msg, True
 
-            lf_span.set_attribute('structured_response', msg)
-            await self._marked_completed(msg)
+        await self._marked_completed(msg)
 
     async def get_data(self) -> ResultDataT:
         """Stream the whole response, validate and return it."""

{pydantic_ai_slim-0.0.31 → pydantic_ai_slim-0.0.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai-slim"
-version = "0.0.31"
+version = "0.0.32"
 description = "Agent Framework / shim to use Pydantic with LLMs, slim package"
 authors = [{ name = "Samuel Colvin", email = "samuel@pydantic.dev" }]
 license = "MIT"
@@ -35,9 +35,8 @@ dependencies = [
     "eval-type-backport>=0.2.0",
     "griffe>=1.3.2",
     "httpx>=0.27",
-    "logfire-api>=1.2.0",
     "pydantic>=2.10",
-    "pydantic-graph==0.0.31",
+    "pydantic-graph==0.0.32",
     "exceptiongroup; python_version < '3.11'",
     "opentelemetry-api>=1.28.0",
 ]
@@ -49,7 +48,7 @@ logfire = ["logfire>=2.3"]
 openai = ["openai>=1.65.1"]
 cohere = ["cohere>=5.13.11"]
 vertexai = ["google-auth>=2.36.0", "requests>=2.32.3"]
-anthropic = ["anthropic>=0.40.0"]
+anthropic = ["anthropic>=0.49.0"]
 groq = ["groq>=0.12.0"]
 mistral = ["mistralai>=1.2.5"]
 # Tools