Merge branch 'main' into toolsets

# Conflicts:
#	pydantic_ai_slim/pydantic_ai/_agent_graph.py
#	pydantic_ai_slim/pydantic_ai/tools.py

Author: DouweM

docs/logfire.md

@@ -323,3 +323,22 @@ agent = Agent('gpt-4o', instrument=instrumentation_settings)
 # or to instrument all agents:
 Agent.instrument_all(instrumentation_settings)
 ```
+
+### Excluding prompts and completions
+
+For privacy and security reasons, you may want to monitor your agent's behavior and performance without exposing sensitive user data or proprietary prompts in your observability platform. PydanticAI allows you to exclude the actual content from instrumentation events while preserving the structural information needed for debugging and monitoring.
+
+When `include_content=False` is set, PydanticAI will exclude sensitive content from OpenTelemetry events, including user prompts and model completions, tool call arguments and responses, and any other message content.
+
+```python {title="excluding_sensitive_content.py"}
+from pydantic_ai.agent import Agent
+from pydantic_ai.models.instrumented import InstrumentationSettings
+
+instrumentation_settings = InstrumentationSettings(include_content=False)
+
+agent = Agent('gpt-4o', instrument=instrumentation_settings)
+# or to instrument all agents:
+Agent.instrument_all(instrumentation_settings)
+```
+
+This setting is particularly useful in production environments where compliance requirements or data sensitivity concerns make it necessary to limit what content is sent to your observability platform.

docs/models/openai.md

@@ -61,7 +61,21 @@ agent = Agent(model)
 
 `OpenAIProvider` also accepts a custom `AsyncOpenAI` client via the `openai_client` parameter, so you can customise the `organization`, `project`, `base_url` etc. as defined in the [OpenAI API docs](https://platform.openai.com/docs/api-reference).
 
-You could also use the [`AsyncAzureOpenAI`](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/switching-endpoints) client to use the Azure OpenAI API.
+```python {title="custom_openai_client.py"}
+from openai import AsyncOpenAI
+
+from pydantic_ai import Agent
+from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.providers.openai import OpenAIProvider
+
+client = AsyncOpenAI(max_retries=3)
+model = OpenAIModel('gpt-4o', provider=OpenAIProvider(openai_client=client))
+agent = Agent(model)
+...
+```
+
+You could also use the [`AsyncAzureOpenAI`](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/switching-endpoints) client
+to use the Azure OpenAI API. Note that the `AsyncAzureOpenAI` is a subclass of `AsyncOpenAI`.
 
 ```python
 from openai import AsyncAzureOpenAI

pydantic_ai_slim/pydantic_ai/_agent_graph.py

@@ -27,7 +27,7 @@
 from .tools import RunContext, ToolDefinition, ToolKind
 
 if TYPE_CHECKING:
-    pass
+    from .models.instrumented import InstrumentationSettings
 
 __all__ = (
     'GraphAgentState',
@@ -115,6 +115,7 @@ class GraphAgentDeps(Generic[DepsT, OutputDataT]):
     toolset: RunToolset[DepsT]
 
     tracer: Tracer
+    instrumentation_settings: InstrumentationSettings | None = None
 
 
 class AgentNode(BaseNode[GraphAgentState, GraphAgentDeps[DepsT, Any], result.FinalResult[NodeRunEndT]]):
@@ -669,6 +670,10 @@ async def process_function_tools(
 
     user_parts: list[_messages.UserPromptPart] = []
 
+    include_content = (
+        ctx.deps.instrumentation_settings is not None and ctx.deps.instrumentation_settings.include_content
+    )
+
     # Run all tool tasks in parallel
     results_by_index: dict[int, _messages.ModelRequestPart] = {}
     with ctx.deps.tracer.start_as_current_span(
@@ -679,7 +684,9 @@ async def process_function_tools(
         },
     ):
         tasks = [
-            asyncio.create_task(_call_function_tool(toolset, call, run_context, ctx.deps.tracer), name=call.tool_name)
+            asyncio.create_task(
+                _call_function_tool(toolset, call, run_context, ctx.deps.tracer, include_content), name=call.tool_name
+            )
             for call in calls_to_run
         ]
 
@@ -736,6 +743,7 @@ async def _call_function_tool(
     tool_call: _messages.ToolCallPart,
     run_context: RunContext[DepsT],
     tracer: Tracer,
+    include_content: bool = False,
 ) -> _messages.ToolReturnPart | _messages.RetryPromptPart:
     """Run the tool function asynchronously.
 
@@ -745,14 +753,14 @@ async def _call_function_tool(
         'gen_ai.tool.name': tool_call.tool_name,
         # NOTE: this means `gen_ai.tool.call.id` will be included even if it was generated by pydantic-ai
         'gen_ai.tool.call.id': tool_call.tool_call_id,
-        'tool_arguments': tool_call.args_as_json_str(),
+        **({'tool_arguments': tool_call.args_as_json_str()} if include_content else {}),
         'logfire.msg': f'running tool: {tool_call.tool_name}',
         # add the JSON schema so these attributes are formatted nicely in Logfire
         'logfire.json_schema': json.dumps(
             {
                 'type': 'object',
                 'properties': {
-                    'tool_arguments': {'type': 'object'},
+                    **({'tool_arguments': {'type': 'object'}} if include_content else {}),
                     'gen_ai.tool.name': {},
                     'gen_ai.tool.call.id': {},
                 },

pydantic_ai_slim/pydantic_ai/agent.py

@@ -743,6 +743,7 @@ async def get_instructions(run_context: RunContext[AgentDepsT]) -> str | None:
             toolset=run_toolset,
             tracer=tracer,
             get_instructions=get_instructions,
+            instrumentation_settings=instrumentation_settings,
         )
         start_node = _agent_graph.UserPromptNode[AgentDepsT](
             user_prompt=user_prompt,

pydantic_ai_slim/pydantic_ai/messages.py

@@ -76,8 +76,11 @@ class SystemPromptPart:
     part_kind: Literal['system-prompt'] = 'system-prompt'
     """Part type identifier, this is available on all parts as a discriminator."""
 
-    def otel_event(self, _settings: InstrumentationSettings) -> Event:
-        return Event('gen_ai.system.message', body={'content': self.content, 'role': 'system'})
+    def otel_event(self, settings: InstrumentationSettings) -> Event:
+        return Event(
+            'gen_ai.system.message',
+            body={'role': 'system', **({'content': self.content} if settings.include_content else {})},
+        )
 
     __repr__ = _utils.dataclasses_no_defaults_repr
 
@@ -362,12 +365,12 @@ def otel_event(self, settings: InstrumentationSettings) -> Event:
             content = []
             for part in self.content:
                 if isinstance(part, str):
-                    content.append(part)
+                    content.append(part if settings.include_content else {'kind': 'text'})
                 elif isinstance(part, (ImageUrl, AudioUrl, DocumentUrl, VideoUrl)):
-                    content.append({'kind': part.kind, 'url': part.url})
+                    content.append({'kind': part.kind, **({'url': part.url} if settings.include_content else {})})
                 elif isinstance(part, BinaryContent):
                     converted_part = {'kind': part.kind, 'media_type': part.media_type}
-                    if settings.include_binary_content:
+                    if settings.include_content and settings.include_binary_content:
                         converted_part['binary_content'] = base64.b64encode(part.data).decode()
                     content.append(converted_part)
                 else:
@@ -414,10 +417,15 @@ def model_response_object(self) -> dict[str, Any]:
         else:
             return {'return_value': tool_return_ta.dump_python(self.content, mode='json')}
 
-    def otel_event(self, _settings: InstrumentationSettings) -> Event:
+    def otel_event(self, settings: InstrumentationSettings) -> Event:
         return Event(
             'gen_ai.tool.message',
-            body={'content': self.content, 'role': 'tool', 'id': self.tool_call_id, 'name': self.tool_name},
+            body={
+                **({'content': self.content} if settings.include_content else {}),
+                'role': 'tool',
+                'id': self.tool_call_id,
+                'name': self.tool_name,
+            },
         )
 
     __repr__ = _utils.dataclasses_no_defaults_repr
@@ -473,14 +481,14 @@ def model_response(self) -> str:
             description = f'{len(self.content)} validation errors: {json_errors.decode()}'
         return f'{description}\n\nFix the errors and try again.'
 
-    def otel_event(self, _settings: InstrumentationSettings) -> Event:
+    def otel_event(self, settings: InstrumentationSettings) -> Event:
         if self.tool_name is None:
             return Event('gen_ai.user.message', body={'content': self.model_response(), 'role': 'user'})
         else:
             return Event(
                 'gen_ai.tool.message',
                 body={
-                    'content': self.model_response(),
+                    **({'content': self.model_response()} if settings.include_content else {}),
                     'role': 'tool',
                     'id': self.tool_call_id,
                     'name': self.tool_name,
@@ -657,7 +665,7 @@ class ModelResponse:
     vendor_id: str | None = None
     """Vendor ID as specified by the model provider. This can be used to track the specific request to the model."""
 
-    def otel_events(self) -> list[Event]:
+    def otel_events(self, settings: InstrumentationSettings) -> list[Event]:
         """Return OpenTelemetry events for the response."""
         result: list[Event] = []
 
@@ -683,7 +691,8 @@ def new_event_body():
             elif isinstance(part, TextPart):
                 if body.get('content'):
                     body = new_event_body()
-                body['content'] = part.content
+                if settings.include_content:
+                    body['content'] = part.content
 
         return result
 

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -342,15 +342,13 @@ async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[Be
                         if response_part.content:  # Only add non-empty text
                             assistant_content_params.append(BetaTextBlockParam(text=response_part.content, type='text'))
                     elif isinstance(response_part, ThinkingPart):
-                        # NOTE: We don't send ThinkingPart to the providers yet. If you are unsatisfied with this,
-                        # please open an issue. The below code is the code to send thinking to the provider.
-                        # assert response_part.signature is not None, 'Thinking part must have a signature'
-                        # assistant_content_params.append(
-                        #     BetaThinkingBlockParam(
-                        #         thinking=response_part.content, signature=response_part.signature, type='thinking'
-                        #     )
-                        # )
-                        pass
+                        # NOTE: We only send thinking part back for Anthropic, otherwise they raise an error.
+                        if response_part.signature is not None:  # pragma: no branch
+                            assistant_content_params.append(
+                                BetaThinkingBlockParam(
+                                    thinking=response_part.content, signature=response_part.signature, type='thinking'
+                                )
+                            )
                     else:
                         tool_use_block_param = BetaToolUseBlockParam(
                             id=_guard_tool_call_id(t=response_part),

pydantic_ai_slim/pydantic_ai/models/instrumented.py

@@ -92,6 +92,7 @@ def __init__(
         meter_provider: MeterProvider | None = None,
         event_logger_provider: EventLoggerProvider | None = None,
         include_binary_content: bool = True,
+        include_content: bool = True,
     ):
         """Create instrumentation options.
 
@@ -109,6 +110,8 @@ def __init__(
                 Calling `logfire.configure()` sets the global event logger provider, so most users don't need this.
                 This is only used if `event_mode='logs'`.
             include_binary_content: Whether to include binary content in the instrumentation events.
+            include_content: Whether to include prompts, completions, and tool call arguments and responses
+                in the instrumentation events.
         """
         from pydantic_ai import __version__
 
@@ -121,6 +124,7 @@ def __init__(
         self.event_logger = event_logger_provider.get_event_logger(scope_name, __version__)
         self.event_mode = event_mode
         self.include_binary_content = include_binary_content
+        self.include_content = include_content
 
         # As specified in the OpenTelemetry GenAI metrics spec:
         # https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-metrics/#metric-gen_aiclienttokenusage
@@ -161,7 +165,7 @@ def messages_to_otel_events(self, messages: list[ModelMessage]) -> list[Event]:
                     if hasattr(part, 'otel_event'):
                         message_events.append(part.otel_event(self))
             elif isinstance(message, ModelResponse):  # pragma: no branch
-                message_events = message.otel_events()
+                message_events = message.otel_events(self)
             for event in message_events:
                 event.attributes = {
                     'gen_ai.message.index': message_index,