Fix Pydantic serialization by making _lock a property

- Convert _lock from dataclass field to property to avoid serialization issues
- Lock is created on-demand via __lock attribute
- Maintains thread safety while allowing Pydantic TypeAdapter serialization
- Fixes PydanticSchemaGenerationError in test_agent_run_result_serialization

Author: certainly-param

pydantic_ai_slim/pydantic_ai/usage.py

@@ -190,9 +190,20 @@ class RunUsage(UsageBase):
     details: dict[str, int] = dataclasses.field(default_factory=dict)
     """Any extra details returned by the model."""
 
-    _lock: threading.Lock = dataclasses.field(default_factory=threading.Lock, compare=False, repr=False)
     """Lock to prevent race conditions when incrementing usage from concurrent tool calls."""
 
+    def __post_init__(self) -> None:
+        """Initialize the lock after dataclass initialization."""
+        if not hasattr(self, '_lock'):
+            self._lock = threading.Lock()
+
+    @property
+    def _lock(self) -> threading.Lock:
+        """Get the lock, creating it if it doesn't exist."""
+        if not hasattr(self, '__lock'):
+            self.__lock = threading.Lock()
+        return self.__lock
+
     def incr(self, incr_usage: RunUsage | RequestUsage) -> None:
         """Increment the usage in place.
 
@@ -214,8 +225,7 @@ def __add__(self, other: RunUsage | RequestUsage) -> RunUsage:
         # Note: We can't use await here since __add__ must be synchronous
         # But __add__ creates a new object, so there's no race condition
         # The race condition only happens when modifying the same object concurrently
-        # Create a new lock for the new instance
-        new_usage._lock = threading.Lock()
+        # The new instance will get its own lock via the property
 
         if isinstance(other, RunUsage):
             new_usage.requests += other.requests
@@ -226,15 +236,16 @@ def __add__(self, other: RunUsage | RequestUsage) -> RunUsage:
     def __getstate__(self) -> dict[str, Any]:
         """Exclude the lock from pickling."""
         state = self.__dict__.copy()
-        # Remove the lock since it can't be pickled
+        # Remove any lock-related attributes since they can't be pickled
         state.pop('_lock', None)
+        state.pop('__lock', None)
         return state
 
     def __setstate__(self, state: dict[str, Any]) -> None:
         """Restore state and create a new lock."""
         self.__dict__.update(state)
-        # Create a new lock for the unpickled instance
-        self._lock = threading.Lock()
+        # The lock will be created automatically via the property
+
 
 
 def _incr_usage_tokens(slf: RunUsage | RequestUsage, incr_usage: RunUsage | RequestUsage) -> None: