fix pydantic

Author: penguine-ip

deepeval/integrations/README.md

@@ -6,19 +6,25 @@ Contributor reference for the framework integrations. Each integration plugs dee
 
 ## Integration matrix
 
-| Integration | Mode | Entry point | Transport | Source |
-|---|---|---|---|---|
-| OpenAI | Native client wrapper | `from deepeval.openai import OpenAI` | REST | `deepeval/openai/` |
-| Anthropic | Native client wrapper | `from deepeval.anthropic import Anthropic` | REST | `deepeval/anthropic/` |
-| LangChain | Callback handler | `CallbackHandler()` | REST | `deepeval/integrations/langchain/` |
-| LangGraph | Callback handler (LangChain's) | `CallbackHandler()` | REST | `deepeval/integrations/langchain/` |
-| LlamaIndex | Event handler | `instrument_llama_index()` | REST | `deepeval/integrations/llama_index/` |
-| CrewAI | Event listener + wrapper classes | `instrument_crewai()` | REST | `deepeval/integrations/crewai/` |
-| Hugging Face | Trainer callback | `DeepEvalHuggingFaceCallback(...)` | REST | `deepeval/integrations/hugging_face/` |
-| OpenAI Agents | Trace processor + agent wrapper | `add_trace_processor(DeepEvalTracingProcessor())` | REST | `deepeval/openai_agents/` |
-| AgentCore | OpenTelemetry | `instrument_agentcore()` | OTLP | `deepeval/integrations/agentcore/` |
-| Google ADK | OpenTelemetry (via OpenInference) | `instrument_google_adk()` | OTLP | `deepeval/integrations/google_adk/` |
-| Pydantic AI | OpenTelemetry | `ConfidentInstrumentationSettings(...)` | OTLP | `deepeval/integrations/pydantic_ai/` |
+The "Mixes with `@observe`?" column tracks whether the integration's spans flow into deepeval's native trace context — i.e. whether `@observe`, `with trace(...)`, `update_current_trace(...)`, and `update_current_span(...)` work transparently for that integration's spans, anywhere in the call stack (Langfuse-style).
+
+- **Good** — trace metadata flows from `update_current_trace(...)`, span metadata flows from `update_current_span(...)`, and spans land in `trace_manager` so pytest tracing evals + `evals_iterator` work. Single REST POST per trace.
+- **Bad** — only the trace UUID syncs between transports. Per-call metadata is locked at `instrument_*()` time; `update_current_span(...)` from inside a tool / callback is a no-op. Dual-posts (REST from `@observe` + OTLP from the integration) reconciled server-side by UUID.
+
+| Integration     | Mode                              | Entry point                                       | Transport                                    | Mixes with `@observe`?                                      | Source                               |
+| --------------- | --------------------------------- | ------------------------------------------------- | -------------------------------------------- | ----------------------------------------------------------- | ------------------------------------ |
+| OpenAI          | Native client wrapper             | `from deepeval.openai import OpenAI`              | REST                                         | Good                                                        | `deepeval/openai/`                   |
+| Anthropic       | Native client wrapper             | `from deepeval.anthropic import Anthropic`        | REST                                         | Good                                                        | `deepeval/anthropic/`                |
+| LangChain       | Callback handler                  | `CallbackHandler()`                               | REST                                         | Good                                                        | `deepeval/integrations/langchain/`   |
+| LangGraph       | Callback handler (LangChain's)    | `CallbackHandler()`                               | REST                                         | Good                                                        | `deepeval/integrations/langchain/`   |
+| LlamaIndex      | Event handler                     | `instrument_llama_index()`                        | REST                                         | Good                                                        | `deepeval/integrations/llama_index/` |
+| CrewAI          | Event listener + wrapper classes  | `instrument_crewai()`                             | REST                                         | Good                                                        | `deepeval/integrations/crewai/`      |
+| OpenAI Agents   | Trace processor + agent wrapper   | `add_trace_processor(DeepEvalTracingProcessor())` | REST                                         | Good                                                        | `deepeval/openai_agents/`            |
+| AgentCore       | OpenTelemetry                     | `instrument_agentcore()`                          | OTLP                                         | Bad — needs the Pydantic AI POC pattern applied[^poc] | `deepeval/integrations/agentcore/`   |
+| Google ADK      | OpenTelemetry (via OpenInference) | `instrument_google_adk()`                         | OTLP                                         | Bad — needs the Pydantic AI POC pattern applied[^poc] | `deepeval/integrations/google_adk/`  |
+| **Pydantic AI** | **OpenTelemetry**                 | **`ConfidentInstrumentationSettings(...)`**       | **REST when context active, OTLP otherwise** | **Good (POC)**                                              | `deepeval/integrations/pydantic_ai/` |
+
+[^poc]: The Pydantic AI integration is the reference for OTel-mode "Good" behavior. Its `SpanInterceptor` reads trace-level metadata from `current_trace_context` per span (instead of baking it at `instrument_*()` time) and pushes a `BaseSpan` placeholder onto `current_span_context` for each OTel span's lifetime so `update_current_span(...)` from anywhere lands in `confident.span.*` attributes at `on_end`. The `ContextAwareSpanProcessor` (`deepeval/tracing/otel/context_aware_processor.py`) routes spans to REST when a deepeval trace context is active or an evaluation is running, OTLP otherwise. Apply the same pattern to `agentcore/` and `openinference/` (which Google ADK delegates to) to flip those rows to Good.
 
 ## Mode reference
 
@@ -48,4 +54,8 @@ GoogleADKInstrumentor().instrument()
 
 ## Mixing OTel-mode with `@observe`
 
-When an OTel-mode integration runs inside an active `@observe` / `with trace(...)` context, the OTel span interceptor synchronizes the trace UUID (`current_trace_context.uuid = OTel trace_id`) so both transports land on the same trace server-side. This means a mixed trace currently produces one REST POST + one or more OTLP POSTs that the backend reconciles by UUID. See internal notes for the proposed single-transport refactor that would route OTel spans through `ConfidentSpanExporter` (REST) when a deepeval trace is active.
+When an OTel-mode integration runs inside an active `@observe` / `with trace(...)` context, the OTel span interceptor synchronizes the trace UUID (`current_trace_context.uuid = OTel trace_id`) so both transports land on the same trace server-side.
+
+For integrations marked **Good** above, `ContextAwareSpanProcessor` automatically routes the OTel spans through `ConfidentSpanExporter` (REST) when a deepeval trace context is active or an evaluation is running — so a mixed trace produces a single REST POST and `update_current_trace(...)` / `update_current_span(...)` from anywhere in the call stack land on the right span. Pydantic AI is the reference implementation; apply the same pattern (see footnote in the matrix) to migrate AgentCore and OpenInference (Google ADK).
+
+For integrations marked **Bad**, the trace UUID syncs but per-call metadata is locked at `instrument_*()` time and the integration produces dual posts (one REST POST from the `@observe` trace flush + one or more OTLP POSTs from the integration's spans) that the backend reconciles by UUID.

deepeval/integrations/pydantic_ai/__init__.py

@@ -1,4 +1,3 @@
-from .agent import DeepEvalPydanticAIAgent as Agent
 from .instrumentator import ConfidentInstrumentationSettings
 from .otel import instrument_pydantic_ai