Make many more dataclasses kw-only

dmontagu · dmontagu · commit 0faad35f8848 · 2025-08-29T18:22:05.000-06:00
diff --git a/pydantic_ai_slim/pydantic_ai/_agent_graph.py b/pydantic_ai_slim/pydantic_ai/_agent_graph.py
@@ -78,7 +78,7 @@
 """
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(kw_only=True)
 class GraphAgentState:
     """State kept across the execution of the agent graph."""
 
@@ -99,7 +99,7 @@ def increment_retries(self, max_result_retries: int, error: BaseException | None
                 raise exceptions.UnexpectedModelBehavior(message)
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(kw_only=True)
 class GraphAgentDeps(Generic[DepsT, OutputDataT]):
     """Dependencies/config passed to the agent graph."""
 
@@ -151,7 +151,7 @@ def is_agent_node(
     return isinstance(node, AgentNode)
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(kw_only=True)
 class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
     """The node that handles the user prompt and instructions."""
 
@@ -308,18 +308,22 @@ async def _reevaluate_dynamic_prompts(
                             ):
                                 updated_part_content = await runner.run(run_context)
                                 msg.parts[i] = _messages.SystemPromptPart(
-                                    updated_part_content, dynamic_ref=part.dynamic_ref
+                                    content=updated_part_content, dynamic_ref=part.dynamic_ref
                                 )
 
     async def _sys_parts(self, run_context: RunContext[DepsT]) -> list[_messages.ModelRequestPart]:
         """Build the initial messages for the conversation."""
-        messages: list[_messages.ModelRequestPart] = [_messages.SystemPromptPart(p) for p in self.system_prompts]
+        messages: list[_messages.ModelRequestPart] = [
+            _messages.SystemPromptPart(content=p) for p in self.system_prompts
+        ]
         for sys_prompt_runner in self.system_prompt_functions:
             prompt = await sys_prompt_runner.run(run_context)
             if sys_prompt_runner.dynamic:
-                messages.append(_messages.SystemPromptPart(prompt, dynamic_ref=sys_prompt_runner.function.__qualname__))
+                messages.append(
+                    _messages.SystemPromptPart(content=prompt, dynamic_ref=sys_prompt_runner.function.__qualname__)
+                )
             else:
-                messages.append(_messages.SystemPromptPart(prompt))
+                messages.append(_messages.SystemPromptPart(content=prompt))
         return messages
 
 
@@ -359,8 +363,8 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
 
     request: _messages.ModelRequest
 
-    _result: CallToolsNode[DepsT, NodeRunEndT] | None = field(default=None, repr=False)
-    _did_stream: bool = field(default=False, repr=False)
+    _result: CallToolsNode[DepsT, NodeRunEndT] | None = field(repr=False, init=False, default=None)
+    _did_stream: bool = field(repr=False, init=False, default=False)
 
     async def run(
         self, ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]]
@@ -389,13 +393,13 @@ async def stream(
             self._did_stream = True
             ctx.state.usage.requests += 1
             agent_stream = result.AgentStream[DepsT, T](
-                streamed_response,
-                ctx.deps.output_schema,
-                model_request_parameters,
-                ctx.deps.output_validators,
-                build_run_context(ctx),
-                ctx.deps.usage_limits,
-                ctx.deps.tool_manager,
+                _raw_stream_response=streamed_response,
+                _output_schema=ctx.deps.output_schema,
+                _model_request_parameters=model_request_parameters,
+                _output_validators=ctx.deps.output_validators,
+                _run_ctx=build_run_context(ctx),
+                _usage_limits=ctx.deps.usage_limits,
+                _tool_manager=ctx.deps.tool_manager,
             )
             yield agent_stream
             # In case the user didn't manually consume the full stream, ensure it is fully consumed here,
@@ -475,9 +479,9 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
 
     model_response: _messages.ModelResponse
 
-    _events_iterator: AsyncIterator[_messages.HandleResponseEvent] | None = field(default=None, repr=False)
+    _events_iterator: AsyncIterator[_messages.HandleResponseEvent] | None = field(default=None, init=False, repr=False)
     _next_node: ModelRequestNode[DepsT, NodeRunEndT] | End[result.FinalResult[NodeRunEndT]] | None = field(
-        default=None, repr=False
+        default=None, init=False, repr=False
     )
 
     async def run(
diff --git a/pydantic_ai_slim/pydantic_ai/_function_schema.py b/pydantic_ai_slim/pydantic_ai/_function_schema.py
@@ -30,7 +30,7 @@
 __all__ = ('function_schema',)
 
 
-@dataclass
+@dataclass(kw_only=True)
 class FunctionSchema:
     """Internal information about a function schema."""
 
diff --git a/pydantic_ai_slim/pydantic_ai/_run_context.py b/pydantic_ai_slim/pydantic_ai/_run_context.py
@@ -18,7 +18,7 @@
 """Type variable for agent dependencies."""
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, kw_only=True)
 class RunContext(Generic[AgentDepsT]):
     """Information about the current call."""
 
diff --git a/pydantic_ai_slim/pydantic_ai/agent/__init__.py b/pydantic_ai_slim/pydantic_ai/agent/__init__.py
@@ -1428,13 +1428,13 @@ class _AgentFunctionToolset(FunctionToolset[AgentDepsT]):
     def __init__(
         self,
         tools: Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] = [],
-        max_retries: int = 1,
         *,
+        max_retries: int = 1,
         id: str | None = None,
         output_schema: _output.BaseOutputSchema[Any],
     ):
         self.output_schema = output_schema
-        super().__init__(tools, max_retries, id=id)
+        super().__init__(tools, max_retries=max_retries, id=id)
 
     @property
     def id(self) -> str:
diff --git a/pydantic_ai_slim/pydantic_ai/builtin_tools.py b/pydantic_ai_slim/pydantic_ai/builtin_tools.py
@@ -9,7 +9,7 @@
 __all__ = ('AbstractBuiltinTool', 'WebSearchTool', 'WebSearchUserLocation', 'CodeExecutionTool', 'UrlContextTool')
 
 
-@dataclass
+@dataclass(kw_only=True)
 class AbstractBuiltinTool(ABC):
     """A builtin tool that can be used by an agent.
 
@@ -19,7 +19,7 @@ class AbstractBuiltinTool(ABC):
     """
 
 
-@dataclass
+@dataclass(kw_only=True)
 class WebSearchTool(AbstractBuiltinTool):
     """A builtin tool that allows your agent to search the web for information.
 
diff --git a/pydantic_ai_slim/pydantic_ai/common_tools/duckduckgo.py b/pydantic_ai_slim/pydantic_ai/common_tools/duckduckgo.py
@@ -36,16 +36,20 @@ class DuckDuckGoResult(TypedDict):
 duckduckgo_ta = TypeAdapter(list[DuckDuckGoResult])
 
 
-@dataclass
+@dataclass(init=False)
 class DuckDuckGoSearchTool:
     """The DuckDuckGo search tool."""
 
     client: DDGS
     """The DuckDuckGo search client."""
 
-    max_results: int | None = None
+    max_results: int | None
     """The maximum number of results. If None, returns results only from the first response."""
 
+    def __init__(self, client: DDGS, *, max_results: int | None = None):
+        self.client = client
+        self.max_results = max_results
+
     async def __call__(self, query: str) -> list[DuckDuckGoResult]:
         """Searches DuckDuckGo for the given query and returns the results.
 
diff --git a/pydantic_ai_slim/pydantic_ai/models/function.py b/pydantic_ai_slim/pydantic_ai/models/function.py
@@ -44,8 +44,8 @@ class FunctionModel(Model):
     Apart from `__init__`, all methods are private or match those of the base class.
     """
 
-    function: FunctionDef | None = None
-    stream_function: StreamFunctionDef | None = None
+    function: FunctionDef | None
+    stream_function: StreamFunctionDef | None
 
     _model_name: str = field(repr=False)
     _system: str = field(default='function', repr=False)
diff --git a/pydantic_ai_slim/pydantic_ai/providers/bedrock.py b/pydantic_ai_slim/pydantic_ai/providers/bedrock.py
@@ -28,7 +28,7 @@
     ) from _import_error
 
 
-@dataclass
+@dataclass(kw_only=True)
 class BedrockModelProfile(ModelProfile):
     """Profile for models used with BedrockModel.
 
diff --git a/pydantic_ai_slim/pydantic_ai/result.py b/pydantic_ai_slim/pydantic_ai/result.py
@@ -42,7 +42,7 @@
 """An invariant TypeVar."""
 
 
-@dataclass
+@dataclass(kw_only=True)
 class AgentStream(Generic[AgentDepsT, OutputDataT]):
     _raw_stream_response: models.StreamedResponse
     _output_schema: OutputSchema[OutputDataT]
diff --git a/pydantic_ai_slim/pydantic_ai/run.py b/pydantic_ai_slim/pydantic_ai/run.py
@@ -101,7 +101,7 @@ def _traceparent(self, *, required: bool = True) -> str | None:
     def ctx(self) -> GraphRunContext[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[AgentDepsT, Any]]:
         """The current context of the agent run."""
         return GraphRunContext[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[AgentDepsT, Any]](
-            self._graph_run.state, self._graph_run.deps
+            state=self._graph_run.state, deps=self._graph_run.deps
         )
 
     @property
diff --git a/pydantic_ai_slim/pydantic_ai/tools.py b/pydantic_ai_slim/pydantic_ai/tools.py
@@ -132,7 +132,7 @@ async def turn_on_strict_if_openai(
 """
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DeferredToolRequests:
     """Tool calls that require approval or external execution.
 
@@ -196,7 +196,7 @@ def _deferred_tool_call_result_discriminator(x: Any) -> str | None:
 """Result for a tool call that required approval or external execution."""
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DeferredToolResults:
     """Results for deferred tool calls from a previous run that required approval or external execution.
 
@@ -430,7 +430,7 @@ async def prepare_tool_def(self, ctx: RunContext[AgentDepsT]) -> ToolDefinition
 """Kind of tool."""
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class ToolDefinition:
     """Definition of a tool passed to a model.
 
diff --git a/pydantic_ai_slim/pydantic_ai/toolsets/abstract.py b/pydantic_ai_slim/pydantic_ai/toolsets/abstract.py
@@ -35,7 +35,7 @@ def validate_python(
     ) -> Any: ...
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ToolsetTool(Generic[AgentDepsT]):
     """Definition of a tool available on a toolset.
 
diff --git a/pydantic_ai_slim/pydantic_ai/toolsets/combined.py b/pydantic_ai_slim/pydantic_ai/toolsets/combined.py
@@ -14,7 +14,7 @@
 from .abstract import AbstractToolset, ToolsetTool
 
 
-@dataclass
+@dataclass(kw_only=True)
 class _CombinedToolsetTool(ToolsetTool[AgentDepsT]):
     """A tool definition for a combined toolset tools that keeps track of the source toolset and tool."""
 
@@ -31,14 +31,9 @@ class CombinedToolset(AbstractToolset[AgentDepsT]):
 
     toolsets: Sequence[AbstractToolset[AgentDepsT]]
 
-    _enter_lock: anyio.Lock = field(compare=False, init=False)
-    _entered_count: int = field(init=False)
-    _exit_stack: AsyncExitStack | None = field(init=False)
-
-    def __post_init__(self):
-        self._enter_lock = anyio.Lock()
-        self._entered_count = 0
-        self._exit_stack = None
+    _enter_lock: anyio.Lock = field(compare=False, init=False, default_factory=anyio.Lock)
+    _entered_count: int = field(init=False, default=0)
+    _exit_stack: AsyncExitStack | None = field(init=False, default=None)
 
     @property
     def id(self) -> str | None:
diff --git a/pydantic_ai_slim/pydantic_ai/toolsets/function.py b/pydantic_ai_slim/pydantic_ai/toolsets/function.py
@@ -19,7 +19,7 @@
 from .abstract import AbstractToolset, ToolsetTool
 
 
-@dataclass
+@dataclass(kw_only=True)
 class FunctionToolsetTool(ToolsetTool[AgentDepsT]):
     """A tool definition for a function toolset tool that keeps track of the function to call."""
 
@@ -40,8 +40,8 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
     def __init__(
         self,
         tools: Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] = [],
-        max_retries: int = 1,
         *,
+        max_retries: int = 1,
         id: str | None = None,
     ):
         """Build a new function toolset.
diff --git a/pydantic_ai_slim/pydantic_ai/usage.py b/pydantic_ai_slim/pydantic_ai/usage.py
@@ -12,7 +12,7 @@
 __all__ = 'RequestUsage', 'RunUsage', 'Usage', 'UsageLimits'
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class UsageBase:
     input_tokens: int = 0
     """Number of input/prompt tokens."""
@@ -75,7 +75,7 @@ def has_values(self) -> bool:
         return any(dataclasses.asdict(self).values())
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class RequestUsage(UsageBase):
     """LLM usage associated with a single request.
 
@@ -107,7 +107,7 @@ def __add__(self, other: RequestUsage) -> RequestUsage:
         return new_usage
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class RunUsage(UsageBase):
     """LLM usage associated with an agent run.
 
@@ -176,13 +176,13 @@ def _incr_usage_tokens(slf: RunUsage | RequestUsage, incr_usage: RunUsage | Requ
         slf.details[key] = slf.details.get(key, 0) + value
 
 
-@dataclass
+@dataclass(repr=False, kw_only=True)
 @deprecated('`Usage` is deprecated, use `RunUsage` instead')
 class Usage(RunUsage):
     """Deprecated alias for `RunUsage`."""
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class UsageLimits:
     """Limits on model usage.
 
diff --git a/pydantic_evals/pydantic_evals/evaluators/context.py b/pydantic_evals/pydantic_evals/evaluators/context.py
@@ -27,7 +27,7 @@
 """Type variable for the metadata associated with the task being evaluated."""
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EvaluatorContext(Generic[InputsT, OutputT, MetadataT]):
     """Context for evaluating a task execution.
 
diff --git a/pydantic_evals/pydantic_evals/otel/span_tree.py b/pydantic_evals/pydantic_evals/otel/span_tree.py
@@ -78,7 +78,7 @@ class SpanQuery(TypedDict, total=False):
     no_ancestor_has: SpanQuery
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class SpanNode:
     """A node in the span tree; provides references to parents/children for easy traversal and queries."""
 
@@ -426,7 +426,7 @@ def __repr__(self) -> str:
 SpanPredicate = Callable[[SpanNode], bool]
 
 
-@dataclass(repr=False)
+@dataclass(repr=False, kw_only=True)
 class SpanTree:
     """A container that builds a hierarchy of SpanNode objects from a list of finished spans.
 
diff --git a/pydantic_evals/pydantic_evals/reporting/__init__.py b/pydantic_evals/pydantic_evals/reporting/__init__.py
diff --git a/pydantic_graph/pydantic_graph/graph.py b/pydantic_graph/pydantic_graph/graph.py
diff --git a/pydantic_graph/pydantic_graph/nodes.py b/pydantic_graph/pydantic_graph/nodes.py
diff --git a/pydantic_graph/pydantic_graph/persistence/__init__.py b/pydantic_graph/pydantic_graph/persistence/__init__.py

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ def _traceparent(self, *, required: bool = True) -> str \| None:`
`101`	`101`	`def ctx(self) -> GraphRunContext[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[AgentDepsT, Any]]:`
`102`	`102`	`"""The current context of the agent run."""`
`103`	`103`	`return GraphRunContext[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[AgentDepsT, Any]](`
`104`		`- self._graph_run.state, self._graph_run.deps`
	`104`	`+ state=self._graph_run.state, deps=self._graph_run.deps`
`105`	`105`	`)`
`106`	`106`
`107`	`107`	`@property`