Revert "rename partial_output to allow_partial"

This reverts commit 4dc4c72.

Author: petersli

docs/durable_execution/temporal.md

@@ -172,7 +172,7 @@ As workflows and activities run in separate processes, any values passed between
 
 To account for these limitations, tool functions and the [event stream handler](#streaming) running inside activities receive a limited version of the agent's [`RunContext`][pydantic_ai.tools.RunContext], and it's your responsibility to make sure that the [dependencies](../dependencies.md) object provided to [`TemporalAgent.run()`][pydantic_ai.durable_exec.temporal.TemporalAgent.run] can be serialized using Pydantic.
 
-Specifically, only the `deps`, `retries`, `tool_call_id`, `tool_name`, `tool_call_approved`, `retry`, `max_retries`, `run_step` and `allow_partial` fields are available by default, and trying to access `model`, `usage`, `prompt`, `messages`, or `tracer` will raise an error.
+Specifically, only the `deps`, `retries`, `tool_call_id`, `tool_name`, `tool_call_approved`, `retry`, `max_retries`, `run_step` and `partial_output` fields are available by default, and trying to access `model`, `usage`, `prompt`, `messages`, or `tracer` will raise an error.
 If you need one or more of these attributes to be available inside activities, you can create a [`TemporalRunContext`][pydantic_ai.durable_exec.temporal.TemporalRunContext] subclass with custom `serialize_run_context` and `deserialize_run_context` class methods and pass it to [`TemporalAgent`][pydantic_ai.durable_exec.temporal.TemporalAgent] as `run_context_type`.
 
 ### Streaming

docs/output.md

@@ -470,10 +470,9 @@ print(result.output)
 
 _(This example is complete, it can be run "as is")_
 
-#### Partial validation {#partial-validation}
+#### Handling partial output in output validators {#partial-output}
 
-You can use the `allow_partial` field on `RunContext` to implement your own partial validation in output validators.
-For example, you could choose to skip validation altogether if `allow_partial` is true:
+You can use the `partial_output` field on `RunContext` to handle validation differently for partial outputs during streaming (e.g. skip validation altogether).
 
 ```python {title="partial_validation_streaming.py" line_length="120"}
 from pydantic_ai import Agent, ModelRetry, RunContext
@@ -482,7 +481,7 @@ agent = Agent('openai:gpt-5')
 
 @agent.output_validator
 def validate_output(ctx: RunContext, output: str) -> str:
-    if ctx.allow_partial:
+    if ctx.partial_output:
         return output
     else:
         if len(output) < 50:

pydantic_ai_slim/pydantic_ai/_run_context.py

@@ -58,8 +58,8 @@ class RunContext(Generic[RunContextAgentDepsT]):
     """The current step in the run."""
     tool_call_approved: bool = False
     """Whether a tool call that required approval has now been approved."""
-    allow_partial: bool = False
-    """Whether to allow partial validation of output."""
+    partial_output: bool = False
+    """Whether the output passed to an output validator is partial."""
 
     @property
     def last_attempt(self) -> bool:

pydantic_ai_slim/pydantic_ai/_tool_manager.py

@@ -147,7 +147,7 @@ async def _call_tool(
                 tool_call_id=call.tool_call_id,
                 retry=self.ctx.retries.get(name, 0),
                 max_retries=tool.max_retries,
-                allow_partial=allow_partial,
+                partial_output=allow_partial,
             )
 
             pyd_allow_partial = 'trailing-strings' if allow_partial else 'off'

pydantic_ai_slim/pydantic_ai/durable_exec/temporal/_run_context.py

@@ -14,7 +14,7 @@
 class TemporalRunContext(RunContext[AgentDepsT]):
     """The [`RunContext`][pydantic_ai.tools.RunContext] subclass to use to serialize and deserialize the run context for use inside a Temporal activity.
 
-    By default, only the `deps`, `retries`, `tool_call_id`, `tool_name`, `tool_call_approved`, `retry`, `max_retries`, `run_step` and `allow_partial` attributes will be available.
+    By default, only the `deps`, `retries`, `tool_call_id`, `tool_name`, `tool_call_approved`, `retry`, `max_retries`, `run_step` and `partial_output` attributes will be available.
     To make another attribute available, create a `TemporalRunContext` subclass with a custom `serialize_run_context` class method that returns a dictionary that includes the attribute and pass it to [`TemporalAgent`][pydantic_ai.durable_exec.temporal.TemporalAgent].
     """
 
@@ -49,7 +49,7 @@ def serialize_run_context(cls, ctx: RunContext[Any]) -> dict[str, Any]:
             'retry': ctx.retry,
             'max_retries': ctx.max_retries,
             'run_step': ctx.run_step,
-            'allow_partial': ctx.allow_partial,
+            'partial_output': ctx.partial_output,
         }
 
     @classmethod

pydantic_ai_slim/pydantic_ai/result.py

@@ -117,7 +117,7 @@ async def stream_text(self, *, delta: bool = False, debounce_by: float | None =
         else:
             async for text in self._stream_response_text(delta=False, debounce_by=debounce_by):
                 for validator in self._output_validators:
-                    text = await validator.validate(text, replace(self._run_ctx, allow_partial=True))
+                    text = await validator.validate(text, replace(self._run_ctx, partial_output=True))
                 yield text
 
     # TODO (v2): Drop in favor of `response` property
@@ -195,7 +195,9 @@ async def validate_response_output(
                 text, self._run_ctx, allow_partial=allow_partial, wrap_validation_errors=False
             )
             for validator in self._output_validators:
-                result_data = await validator.validate(result_data, replace(self._run_ctx, allow_partial=allow_partial))
+                result_data = await validator.validate(
+                    result_data, replace(self._run_ctx, partial_output=allow_partial)
+                )
             return result_data
         else:
             raise exceptions.UnexpectedModelBehavior(  # pragma: no cover

tests/test_agent.py

@@ -339,14 +339,14 @@ def validate_output(ctx: RunContext[None], o: Foo) -> Foo:
 
 
 def test_output_validator_partial_sync():
-    """Test that output validators receive correct value for `allow_partial` in sync mode."""
+    """Test that output validators receive correct value for `partial_output` in sync mode."""
     call_log: list[tuple[str, bool]] = []
 
     agent = Agent[None, str](TestModel(custom_output_text='test output'))
 
     @agent.output_validator
     def validate_output(ctx: RunContext[None], output: str) -> str:
-        call_log.append((output, ctx.allow_partial))
+        call_log.append((output, ctx.partial_output))
         return output
 
     result = agent.run_sync('Hello')
@@ -356,7 +356,7 @@ def validate_output(ctx: RunContext[None], output: str) -> str:
 
 
 async def test_output_validator_partial_stream_text():
-    """Test that output validators receive correct value for `allow_partial` when using stream_text()."""
+    """Test that output validators receive correct value for `partial_output` when using stream_text()."""
     call_log: list[tuple[str, bool]] = []
 
     async def stream_text(messages: list[ModelMessage], info: AgentInfo) -> AsyncIterator[str]:
@@ -367,7 +367,7 @@ async def stream_text(messages: list[ModelMessage], info: AgentInfo) -> AsyncIte
 
     @agent.output_validator
     def validate_output(ctx: RunContext[None], output: str) -> str:
-        call_log.append((output, ctx.allow_partial))
+        call_log.append((output, ctx.partial_output))
         return output
 
     async with agent.run_stream('Hello') as result:
@@ -388,7 +388,7 @@ def validate_output(ctx: RunContext[None], output: str) -> str:
 
 
 async def test_output_validator_partial_stream_output():
-    """Test that output validators receive correct value for `allow_partial` when using stream_output()."""
+    """Test that output validators receive correct value for `partial_output` when using stream_output()."""
     call_log: list[tuple[Foo, bool]] = []
 
     async def stream_model(messages: list[ModelMessage], info: AgentInfo) -> AsyncIterator[DeltaToolCalls]:
@@ -401,7 +401,7 @@ async def stream_model(messages: list[ModelMessage], info: AgentInfo) -> AsyncIt
 
     @agent.output_validator
     def validate_output(ctx: RunContext[None], output: Foo) -> Foo:
-        call_log.append((output, ctx.allow_partial))
+        call_log.append((output, ctx.partial_output))
         return output
 
     async with agent.run_stream('Hello') as result: