Skip to content

Commit 71c2da4

Browse files
fix: preserve tool outputs after callback failures (#5318)
* fix: preserve tool outputs after callback retries * fix: keep callback retry outputs ordered and streamed * fix: complete callback retry delivery and guardrail recovery * fix: keep callback retry outputs private until delivery * fix: retain private callback checkpoints and published history * fix: retain published diagnostics and guard legacy retries
1 parent 911f106 commit 71c2da4

16 files changed

Lines changed: 1840 additions & 106 deletions

‎src/agents/result.py‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@
1111
from pydantic import GetCoreSchemaHandler
1212
from pydantic_core import core_schema
1313

14+
from ._tool_invocation import tool_output_identity
1415
from .agent import Agent
1516
from .agent_output import AgentOutputSchemaBase
1617
from .exceptions import (
@@ -29,6 +30,7 @@
2930
ModelResponse,
3031
RunItem,
3132
ToolApprovalItem,
33+
ToolCallOutputItem,
3234
TResponseInputItem,
3335
)
3436
from .logger import log_tool_action_warning, logger
@@ -292,6 +294,52 @@ def _input_items_for_result(
292294
if not isinstance(model_input_items, list):
293295
return session_items
294296

297+
if isinstance(result, RunResultStreaming):
298+
# Execution checkpoints can contain accepted outputs that final guardrails
299+
# have not released. Keep them private in every public history view.
300+
from .run_internal.blocked_output import (
301+
_current_response_boundary,
302+
_identity_sequence_start,
303+
)
304+
305+
processed = result._last_processed_response
306+
if processed is None and isinstance(result._state, RunState):
307+
processed = result._state._last_processed_response
308+
if processed is not None:
309+
legacy_public_outputs: set[tuple[str, str]] = set()
310+
start = _identity_sequence_start(model_input_items, processed.new_items)
311+
if start is None and isinstance(result._state, RunState):
312+
# Legacy first-turn checkpoints have no shared processed-item identities.
313+
# Prove their boundary against this result's captured history, since the
314+
# caller can resume the source RunState before inspecting an earlier result.
315+
boundary_state = copy.copy(result._state)
316+
boundary_state._generated_items = model_input_items
317+
boundary_state._session_items = result.new_items
318+
boundary_state._current_turn = result.current_turn
319+
boundary = _current_response_boundary((), processed, boundary_state)
320+
start = boundary.generated_start
321+
if start is None and boundary_state._terminal_unrecoverable:
322+
return session_items
323+
if start is not None and boundary.session_start is not None:
324+
public_start = boundary.session_start + len(boundary.processed_items)
325+
legacy_public_outputs = {
326+
identity
327+
for item in result.new_items[public_start:]
328+
if isinstance(item, ToolCallOutputItem)
329+
and (identity := tool_output_identity(item.raw_item)) is not None
330+
}
331+
if start is not None:
332+
output_start = start + len(processed.new_items)
333+
public_items = {id(item) for item in result.new_items}
334+
model_input_items = [
335+
item
336+
for index, item in enumerate(model_input_items)
337+
if index < output_start
338+
or not isinstance(item, ToolCallOutputItem)
339+
or id(item) in public_items
340+
or tool_output_identity(item.raw_item) in legacy_public_outputs
341+
]
342+
295343
# When the runner marks a divergence, generated_items already reflect the continuation input
296344
# chosen for the next local run after applying handoff/input filtering.
297345
return run_items_to_input_items(model_input_items, reasoning_item_id_policy)
@@ -1257,5 +1305,20 @@ def to_state(self) -> RunState[Any]:
12571305
previous_response_id=self._previous_response_id,
12581306
auto_previous_response_id=self._auto_previous_response_id,
12591307
)
1308+
if (
1309+
isinstance(self._state, RunState)
1310+
and self._last_processed_response is not None
1311+
and self._state._last_processed_response is self._last_processed_response
1312+
):
1313+
# The checkpoint retains records withheld from the public result until guardrails pass.
1314+
error = self.run_loop_exception
1315+
if error is not None and _is_error_data_redacted(error):
1316+
state._tool_input_guardrail_results = list(
1317+
self._state._tool_input_guardrail_results
1318+
)
1319+
if self._last_processed_response.tool_output_guardrail_result_start is not None:
1320+
state._tool_output_guardrail_results = list(
1321+
self._state._tool_output_guardrail_results
1322+
)
12601323
_copy_pending_nested_agent_tool_states(state, self)
12611324
return state

‎src/agents/run.py‎

Lines changed: 60 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1157,15 +1157,19 @@ def _mark_response_hooks_started() -> None:
11571157
)
11581158
for item in resumed_response_boundary.items:
11591159
ensure_nested_history_run_item_occurrence_key(item)
1160+
processed = run_state._last_processed_response
1161+
guardrail_result_start = processed.tool_output_guardrail_result_start
11601162
blocked_output_owner_starts = _BlockedOutputOwnerStarts(
11611163
nonstreamed_session_items=(resumed_response_boundary.session_start),
11621164
run_state_generated_items=(
11631165
resumed_response_boundary.generated_start
11641166
),
11651167
run_state_session_items=resumed_response_boundary.session_start,
11661168
run_state_model_responses=len(run_state._model_responses) - 1,
1167-
run_state_tool_output_guardrail_results=len(
1168-
run_state._tool_output_guardrail_results
1169+
run_state_tool_output_guardrail_results=(
1170+
guardrail_result_start
1171+
if guardrail_result_start is not None
1172+
else len(run_state._tool_output_guardrail_results)
11691173
),
11701174
)
11711175

@@ -1198,8 +1202,13 @@ def _mark_response_hooks_started() -> None:
11981202

11991203
input_before_turn_rewrite = original_input
12001204
original_input = turn_result.original_input
1201-
generated_items, turn_session_items = resumed_turn_items(turn_result)
1202-
session_items.extend(turn_session_items)
1205+
generated_items, session_items, turn_session_items = resumed_turn_items(
1206+
turn_result, session_items, run_state
1207+
)
1208+
retry_terminal_output = (
1209+
isinstance(turn_result.next_step, NextStepFinalOutput)
1210+
and turn_result.has_recovered_tool_outputs
1211+
)
12031212
if run_state is not None:
12041213
if turn_result.nested_history_owned_items is not None:
12051214
run_state._nested_history_owned_session_item_refs = (
@@ -1211,12 +1220,13 @@ def _mark_response_hooks_started() -> None:
12111220
turn_result.nested_history_owned_items,
12121221
)
12131222
)
1214-
update_run_state_after_resume(
1215-
run_state,
1216-
turn_result=turn_result,
1217-
generated_items=generated_items,
1218-
session_items=session_items,
1219-
)
1223+
if not retry_terminal_output:
1224+
update_run_state_after_resume(
1225+
run_state,
1226+
turn_result=turn_result,
1227+
generated_items=generated_items,
1228+
session_items=session_items,
1229+
)
12201230
if isinstance(
12211231
turn_result.next_step,
12221232
NextStepInterruption | NextStepHandoff,
@@ -1313,6 +1323,13 @@ def _mark_response_hooks_started() -> None:
13131323
return _finalize_result(result)
13141324

13151325
if isinstance(turn_result.next_step, NextStepRunAgain):
1326+
if turn_result.has_recovered_tool_outputs:
1327+
tool_input_guardrail_results.extend(
1328+
turn_result.tool_input_guardrail_results
1329+
)
1330+
tool_output_guardrail_results.extend(
1331+
turn_result.tool_output_guardrail_results
1332+
)
13161333
continue
13171334

13181335
append_model_response_if_new(
@@ -1416,6 +1433,12 @@ def _mark_response_hooks_started() -> None:
14161433
) from None
14171434
raise
14181435
except (Exception, asyncio.CancelledError) as guardrail_error:
1436+
if retry_terminal_output:
1437+
# Keep accepted execution private and retryable until
1438+
# the final guardrails permit delivery.
1439+
del output_guardrail_results[output_guardrail_result_start:]
1440+
session_items = list(run_state._session_items)
1441+
raise
14191442
if not isinstance(
14201443
guardrail_error, asyncio.CancelledError
14211444
) or not _is_terminal_tool_output_response(
@@ -1444,6 +1467,13 @@ def _mark_response_hooks_started() -> None:
14441467
)
14451468
raise
14461469

1470+
if retry_terminal_output:
1471+
update_run_state_after_resume(
1472+
run_state,
1473+
turn_result=turn_result,
1474+
generated_items=generated_items,
1475+
session_items=session_items,
1476+
)
14471477
final_turn_items = _final_turn_items_for_persistence(
14481478
list(turn_session_items),
14491479
current_processed_response,
@@ -2297,6 +2327,17 @@ async def _save_max_turns_handler_output(
22972327
)
22982328
if isinstance(exc, AgentsException):
22992329
_clear_data_redacted_error_traceback(exc)
2330+
public_tool_output_results = tool_output_guardrail_results
2331+
if (
2332+
run_state is not None
2333+
and isinstance(run_state._current_step, NextStepInterruption)
2334+
and run_state._last_processed_response is not None
2335+
):
2336+
# Pending execution records belong only to the retry checkpoint.
2337+
processed = run_state._last_processed_response
2338+
public_tool_output_results = tool_output_guardrail_results[
2339+
: processed.tool_output_guardrail_result_start
2340+
]
23002341
exc.run_data = RunErrorDetails(
23012342
input=original_input,
23022343
new_items=session_items,
@@ -2306,7 +2347,7 @@ async def _save_max_turns_handler_output(
23062347
input_guardrail_results=input_guardrail_results,
23072348
output_guardrail_results=output_guardrail_results,
23082349
tool_input_guardrail_results=tool_input_guardrail_results,
2309-
tool_output_guardrail_results=tool_output_guardrail_results,
2350+
tool_output_guardrail_results=public_tool_output_results,
23102351
)
23112352
raise
23122353
finally:
@@ -2683,7 +2724,14 @@ def run_streamed(
26832724
else []
26842725
),
26852726
tool_output_guardrail_results=(
2686-
list(getattr(run_state, "_tool_output_guardrail_results", []))
2727+
list(run_state._tool_output_guardrail_results)[
2728+
: (
2729+
run_state._last_processed_response.tool_output_guardrail_result_start
2730+
if isinstance(run_state._current_step, NextStepInterruption)
2731+
and run_state._last_processed_response is not None
2732+
else None
2733+
)
2734+
]
26872735
if run_state is not None
26882736
else []
26892737
),

‎src/agents/run_internal/agent_runner_helpers.py‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -478,6 +478,8 @@ def build_interruption_result(
478478
original_input: str | list[TResponseInputItem],
479479
) -> RunResult:
480480
"""Create a RunResult for an interruption path."""
481+
if processed_response is not None:
482+
processed_response.tool_output_guardrail_result_start = None
481483
identity_root_agent = (
482484
run_state._starting_agent
483485
if run_state is not None and run_state._starting_agent is not None

‎src/agents/run_internal/blocked_output.py‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -748,13 +748,13 @@ def _prepare_blocked_output_owner_plan(
748748
public_results,
749749
slice(len(prefixes.streamed_tool_output_guardrail_results), None),
750750
)
751-
elif run_state is not None:
751+
else:
752+
current_results = []
753+
if not current_results and run_state is not None:
752754
current_results = list.__getitem__(
753755
run_state._tool_output_guardrail_results,
754756
slice(len(prefixes.run_state_tool_output_guardrail_results), None),
755757
)
756-
else:
757-
current_results = []
758758
safe_tool_output_guardrail_results = _data_free_tool_output_guardrail_results(
759759
current_results,
760760
blocked_message,

‎src/agents/run_internal/items.py‎

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717
from pydantic import BaseModel
1818

1919
from .._tool_identity import get_hosted_mcp_approval_request_identity
20+
from .._tool_invocation import tool_output_identity
2021
from ..agent_tool_state import drop_agent_tool_run_result
2122
from ..items import ItemHelpers, RunItem, ToolCallOutputItem, TResponseInputItem
2223
from ..models.fake_id import FAKE_RESPONSES_ID
@@ -68,6 +69,7 @@
6869
"prepare_model_input_items",
6970
"run_item_to_input_item",
7071
"run_items_to_input_items",
72+
"order_current_turn_tool_outputs",
7173
"normalize_input_items_for_api",
7274
"normalize_resumed_input",
7375
"fingerprint_input_item",
@@ -90,6 +92,44 @@
9092
]
9193

9294

95+
def order_current_turn_tool_outputs(
96+
items: Sequence[RunItem],
97+
*,
98+
start: int | None,
99+
call_positions: dict[str, int],
100+
published_items: Sequence[RunItem] = (),
101+
) -> list[RunItem]:
102+
"""Order pending local outputs without moving the response or published history."""
103+
ordered_items = list(items)
104+
if start is None:
105+
return ordered_items
106+
published_ids = {
107+
identity
108+
for item in published_items
109+
if isinstance(item, ToolCallOutputItem)
110+
and (identity := tool_output_identity(item.raw_item)) is not None
111+
}
112+
for index in range(start, len(ordered_items)):
113+
if (
114+
isinstance(ordered_items[index], ToolCallOutputItem)
115+
and tool_output_identity(ordered_items[index].raw_item) in published_ids
116+
):
117+
start = index + 1
118+
slots = [
119+
index
120+
for index in range(start, len(ordered_items))
121+
if isinstance(item := ordered_items[index], ToolCallOutputItem)
122+
and item.call_id in call_positions
123+
]
124+
outputs = sorted(
125+
(ordered_items[index] for index in slots),
126+
key=lambda item: call_positions[cast(ToolCallOutputItem, item).call_id or ""],
127+
)
128+
for index, output in zip(slots, outputs, strict=True):
129+
ordered_items[index] = output
130+
return ordered_items
131+
132+
93133
@dataclass(frozen=True)
94134
class NestedHistoryOwnedItem:
95135
"""A run item and the exact nested-input occurrence that represents it."""

0 commit comments

Comments
 (0)