Skip to content

The agent that grows with you

fix(api_server): a cancel during the terminal commit never overwrites it with incomplete

Tekniume4865f9d7fc0
diff --git a/gateway/platforms/api_server_openai_routes.py b/gateway/platforms/api_server_openai_routes.py
index 22ff2e2a119..fda9baeb706 100644
--- a/gateway/platforms/api_server_openai_routes.py
+++ b/gateway/platforms/api_server_openai_routes.py
@@ -384,6 +384,9 @@ class _ResponsesStream:
conversation pointer can not interleave with another observer's."""
if self.durable_key and _settled(self.response_store.get(self.durable_key[0])):
return # A concurrent observer already committed the exact terminal envelope.
+ if response_env.get('status') == 'incomplete' and self.terminal_snapshot_persisted:
+ # A cancel that interrupted the await of a terminal commit: its worker still finished it.
+ return
advance_conversation = self.conversation and (not self.terminal_replay
or self.response_store.get_conversation(self.conversation) in (None, self.response_id))
self.response_store.put(self.response_id, {
@@ -393,6 +396,9 @@ class _ResponsesStream:
"session_id": session_id or self.session_id})
if advance_conversation:
self.response_store.set_conversation(self.conversation, self.response_id)
+ if response_env.get('status') != 'in_progress':
+ # Set by the worker, under the store lock: a cancel of the awaiting handler cannot lose it.
+ self.terminal_snapshot_persisted = True
async def persist_incomplete_if_needed(self) -> None:
"""Persist an ``incomplete`` snapshot when no terminal one was written (disconnect /
@@ -647,7 +653,6 @@ class _ResponsesStream:
history.append(
{"role": "assistant", "content": self.final_response_text or redact(self.agent_error)})
await self.persist_snapshot(env, history=history)
- self.terminal_snapshot_persisted = True
await self.write_event("response.failed", {"type": "response.failed", "response": env})
async def emit_completed(self) -> dict[str, Any]:
@@ -678,7 +683,6 @@ class _ResponsesStream:
'events': [*self.recorded_events, ('response.' + status, terminal_event)]}
stored = await self.response_store.off_loop(
self._commit_terminal, env, full_history, sid if isinstance(sid, str) and sid else None, record)
- self.terminal_snapshot_persisted = True
if self.durable_key:
if _settled(stored):
env = stored['response']
@@ -1284,11 +1288,12 @@ class OpenAICompatRoutesMixin:
await _abandon_agent_task(agent_ref, agent_task, "SSE client disconnected")
logger.info("SSE client disconnected; interrupted agent task %s", response_id)
except asyncio.CancelledError:
- # Server-side cancellation (shutdown, timeout): persist incomplete, then re-raise.
- await st.persist_incomplete_if_needed()
+ # Server-side cancellation (shutdown, timeout): abandon the agent first (a second cancel
+ # landing in the persist await must not skip it), persist incomplete, then re-raise.
await _abandon_agent_task(
agent_ref, agent_task, "SSE task cancelled",
reap_source="api_server_sse_cancelled", await_cancel=False)
+ await st.persist_incomplete_if_needed()
logger.info("SSE task cancelled; persisted incomplete snapshot for %s", response_id)
raise
except Exception as exc:
diff --git a/tests/gateway/test_responses_cancel_keeps_terminal.py b/tests/gateway/test_responses_cancel_keeps_terminal.py
new file mode 100644
index 00000000000..f37975cc6d6
--- /dev/null
+++ b/tests/gateway/test_responses_cancel_keeps_terminal.py
@@ -0,0 +1,43 @@
+"""A cancel landing while the terminal snapshot commits off the loop never overwrites it with
+``incomplete``: the commit's worker keeps running after its awaiting handler is cancelled."""
+import asyncio
+import threading
+
+import pytest
+
+from gateway.platforms.api_server_openai_routes import _ResponsesStream
+
+
+class _Sink:
+ async def write(self, frame):
+ pass
+
+
+async def test_cancel_during_the_terminal_commit_keeps_the_completed_snapshot(api):
+ store = api._current_response_store()
+ entered, release = threading.Event(), threading.Event()
+ real_put = store.put
+
+ def slow_put(response_id, data):
+ if data.get('response', {}).get('status') == 'completed':
+ entered.set()
+ release.wait(5)
+ return real_put(response_id, data)
+
+ store.put = slow_put
+ stream = _ResponsesStream(api, _Sink(), response_id='resp_cancel', model='m', created_at=0,
+ conversation_history=[], user_message='hi', instructions=None,
+ conversation=None, store=True, session_id='s')
+ stream.result = {'final_response': 'done', 'messages': []}
+ stream.final_response_text = 'done'
+ completing = asyncio.create_task(stream.emit_completed())
+ assert await asyncio.to_thread(entered.wait, 5) # the completed snapshot is being written
+ completing.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await completing
+ # _write_sse_responses' CancelledError branch.
+ incomplete = asyncio.create_task(stream.persist_incomplete_if_needed())
+ release.set()
+ await incomplete
+ assert store.get('resp_cancel')['response']['status'] == 'completed'