Skip to content

CubeLoop — a Pythonic, async-native agent harness core designed for high performance, readability, and production-grade persistence.

fix(session): preserve accepted lifecycle ownership

xfgongc19a32c40a8c
diff --git a/cubeloop/agent/agent.py b/cubeloop/agent/agent.py
index 4ba3618..9b3b5c8 100644
--- a/cubeloop/agent/agent.py
+++ b/cubeloop/agent/agent.py
@@ -1232,6 +1232,8 @@ class Agent(Generic[TMessage]):
self._state.is_streaming = True
self._state.streaming_message = None
self._state.error_message = None
+ if self.session._cancel_requested:
+ signal.set()
try:
await executor(signal)
diff --git a/cubeloop/session/session.py b/cubeloop/session/session.py
index de0c7bf..38820da 100644
--- a/cubeloop/session/session.py
+++ b/cubeloop/session/session.py
@@ -39,6 +39,7 @@ from cubeloop.types import JsonObject
if TYPE_CHECKING:
from cubeloop.agent.agent import Agent
+ from cubeloop.providers.base import Message
from cubeloop.session.turn_execution_context import TurnExecutionContext
@@ -87,6 +88,7 @@ class ExecutionSession:
self._required_delivery_failure: DeliveryError | None = None
self._consumers: list[_Consumer] = []
self._input_status: dict[str, InputStatus] = {}
+ self._queued_inputs: dict[str, Message] = {}
self._delivery_errors: list[DeliveryError] = []
self._turn_contexts: list[TurnExecutionContext] = []
self._pending_request: HitlRequest | None = None
@@ -213,16 +215,20 @@ class ExecutionSession:
return InputReceipt(input_id=envelope.input_id, status="closed")
del self._input_status[terminal_id]
- metadata = dict(envelope.message.metadata)
+ message = envelope.message.model_copy(deep=True)
+ metadata = dict(message.metadata)
metadata["input_id"] = envelope.input_id
metadata["input_mode"] = envelope.mode
metadata["steer_id"] = envelope.input_id
- message = envelope.message.model_copy(update={"metadata": metadata})
+ message = message.model_copy(
+ update={"metadata": metadata, "run_id": self._active_run_id}
+ )
if envelope.mode == "steer":
self._agent.steer(message)
else:
self._agent.follow_up(message)
self._input_status[envelope.input_id] = "queued"
+ self._queued_inputs[envelope.input_id] = message
return InputReceipt(input_id=envelope.input_id, status="queued")
def cancel_input(self, input_id: str) -> InputReceipt:
@@ -246,6 +252,7 @@ class ExecutionSession:
if not removed:
return InputReceipt(input_id=input_id, status="closed")
self._input_status[input_id] = "cancelled"
+ self._queued_inputs.pop(input_id, None)
return InputReceipt(input_id=input_id, status="cancelled")
async def execute(self, request: ExecutionRequest) -> ExecutionResult:
@@ -266,6 +273,7 @@ class ExecutionSession:
self._agent._steering_queue.remove(input_id)
self._agent._follow_up_queue.remove(input_id)
del self._input_status[input_id]
+ self._queued_inputs.pop(input_id, None)
self._turn_contexts.clear()
self._pending_request = None
caught: BaseException | None = None
@@ -371,8 +379,10 @@ class ExecutionSession:
if (
isinstance(input_id, str)
and self._input_status.get(input_id) == "queued"
+ and self._queued_inputs.get(input_id) is event.message
):
self._input_status[input_id] = "committed"
+ self._queued_inputs.pop(input_id, None)
committed_input_id = input_id
await self._publish(event, terminal=False)
if committed_input_id is None:
@@ -532,19 +542,20 @@ class ExecutionSession:
history_consistent = False
pending = None
+ pending_is_durable = False
if self._agent.checkpointer is not None and self._agent.thread_id is not None:
load_pending = getattr(self._agent.checkpointer, "load_pending", None)
if load_pending is not None:
loaded = await load_pending(self._agent.thread_id)
- pending = loaded[0] if loaded is not None else None
+ if loaded is not None:
+ pending = loaded[0].model_copy(deep=True)
+ pending_is_durable = True
if pending is None:
pending = self._pending_request
private_outcome = self._agent.state.last_outcome
error: ExecutionError | None = None
- if isinstance(caught, asyncio.CancelledError) or (
- private_outcome == "abandoned" and self._cancel_requested
- ):
+ if isinstance(caught, asyncio.CancelledError) or self._cancel_requested:
outcome: ExecutionOutcome = "cancelled"
error = ExecutionError(
kind="cancelled",
@@ -575,10 +586,9 @@ class ExecutionSession:
)
error = ExecutionError(kind="execution", message=message)
- checkpoint_committed = self._has_durable_checkpoint() and outcome in {
- "completed",
- "suspended",
- }
+ checkpoint_committed = self._has_durable_checkpoint() and (
+ outcome == "completed" or (outcome == "suspended" and pending_is_durable)
+ )
return ExecutionResult(
run_id=request.run_id,
attempt_id=request.attempt_id,
diff --git a/tests/agent/test_execution_session.py b/tests/agent/test_execution_session.py
index 62ea22b..3082088 100644
--- a/tests/agent/test_execution_session.py
+++ b/tests/agent/test_execution_session.py
@@ -434,6 +434,7 @@ async def test_detach_rejects_outside_hitl_safe_point() -> None:
@pytest.mark.asyncio
async def test_in_memory_detach_returns_pending_request() -> None:
channel = InMemoryChannel(thread_id="thread-1")
+ checkpointer = MemoryCheckpointer()
provider = _provider(
AssistantMessage(
content=[
@@ -450,6 +451,8 @@ async def test_in_memory_detach_returns_pending_request() -> None:
model=provider.model("faux-model"),
tools=[ask_user_tool(channel)],
channel=channel,
+ checkpointer=checkpointer,
+ thread_id="thread-1",
)
execution = asyncio.create_task(
agent.session.execute(
@@ -467,5 +470,66 @@ async def test_in_memory_detach_returns_pending_request() -> None:
result = await execution
assert result.outcome == "suspended"
+ assert result.checkpoint_committed is False
assert result.pending_request is not None
assert result.pending_request.question_id == question_id
+
+
+async def test_loaded_pending_request_is_copied_before_result_exposure() -> None:
+ checkpointer = MemoryCheckpointer()
+ pending = HitlRequest(
+ question_id="question-1",
+ thread_id="thread-1",
+ payload=ConfirmRequest(prompt="original"),
+ created_at=0,
+ )
+ await checkpointer.save_pending_request("thread-1", pending, run_id="run-1")
+ agent = Agent(
+ model=_provider(_answer()).model("faux-model"),
+ checkpointer=checkpointer,
+ thread_id="thread-1",
+ )
+ agent._state.last_outcome = "suspended"
+
+ result = await agent.session._settle(
+ PromptExecutionRequest(run_id="run-1", attempt_id="attempt-1", message="hi"),
+ None,
+ )
+ assert result.pending_request is not None
+ result.pending_request.payload.prompt = "mutated"
+
+ loaded = await checkpointer.load_pending("thread-1")
+ assert loaded is not None
+ assert loaded[0].payload.prompt == "original"
+
+
+async def test_cancel_requested_during_startup_reaches_new_run_signal() -> None:
+ entered = asyncio.Event()
+ release = asyncio.Event()
+
+ class SlowClaimCheckpointer(MemoryCheckpointer):
+ async def claim_run(self, thread_id: str, run_id: str) -> None:
+ entered.set()
+ await release.wait()
+ await super().claim_run(thread_id, run_id)
+
+ checkpointer = SlowClaimCheckpointer()
+ agent = Agent(
+ model=_provider(_answer()).model("faux-model"),
+ checkpointer=checkpointer,
+ thread_id="thread-1",
+ )
+ task = asyncio.create_task(
+ agent.session.execute(
+ PromptExecutionRequest(run_id="run-1", attempt_id="attempt-1", message="hi")
+ )
+ )
+ await asyncio.wait_for(entered.wait(), timeout=1)
+
+ agent.session.request_cancel()
+ release.set()
+ result = await task
+
+ assert result.outcome == "cancelled"
diff --git a/tests/agent/test_session_input.py b/tests/agent/test_session_input.py
index cab7359..6d14ed6 100644
--- a/tests/agent/test_session_input.py
+++ b/tests/agent/test_session_input.py
@@ -5,6 +5,7 @@ import asyncio
import pytest
from cubeloop import Agent
+from cubeloop.agent.types import MessageEndEvent
from cubeloop.checkpointer.memory import MemoryCheckpointer
from cubeloop.providers.base import AssistantMessage, TextContent, UserMessage
from cubeloop.providers.faux import FauxProvider
@@ -479,3 +480,92 @@ async def test_cancelled_attempt_discards_its_undrained_input_queue() -> None:
assert agent.session.cancel_input("retry-id").status == "cancelled"
release_second.set()
assert await second == "run-2"
+
+
+async def test_accepted_input_isolated_from_later_caller_mutation() -> None:
+ entered = asyncio.Event()
+ release = asyncio.Event()
+
+ async def first_response(messages, model):
+ del messages, model
+ entered.set()
+ await release.wait()
+ return AssistantMessage(
+ content=[TextContent(text="first")], stop_reason="end_turn"
+ )
+
+ provider = FauxProvider(provider_id="faux")
+ provider.set_responses(
+ [
+ first_response,
+ AssistantMessage(
+ content=[TextContent(text="done")], stop_reason="end_turn"
+ ),
+ ]
+ )
+ agent = Agent(model=provider.model("faux-model"))
+ task = asyncio.create_task(agent.prompt("hi", run_id="run-1"))
+ await asyncio.wait_for(entered.wait(), timeout=1)
+ message = UserMessage(
+ content=[TextContent(text="original")], metadata={"nested": {"value": 1}}
+ )
+ assert (
+ agent.session.submit_input(
+ InputEnvelope(input_id="input-1", message=message, mode="follow_up")
+ ).status
+ == "queued"
+ )
+
+ message.content[0].text = "mutated"
+ message.metadata["nested"]["value"] = 2
+ release.set()
+ assert await task == "run-1"
+
+ accepted = next(
+ item
+ for item in agent.state.messages
+ if item.metadata.get("input_id") == "input-1"
+ )
+ assert accepted.content[0].text == "original"
+ assert accepted.metadata["nested"]["value"] == 1
+
+
+async def test_matching_caller_metadata_cannot_commit_an_unrelated_message() -> None:
+ entered = asyncio.Event()
+ release = asyncio.Event()
+
+ async def response(messages, model):
+ del messages, model
+ entered.set()
+ await release.wait()
+ return AssistantMessage(
+ content=[TextContent(text="done")], stop_reason="end_turn"
+ )
+
+ provider = FauxProvider(provider_id="faux")
+ provider.set_responses([response])
+ agent = Agent(model=provider.model("faux-model"))
+ task = asyncio.create_task(agent.prompt("hi", run_id="run-1"))
+ await asyncio.wait_for(entered.wait(), timeout=1)
+ envelope = InputEnvelope(
+ input_id="input-1",
+ message=UserMessage(content=[TextContent(text="actual")]),
+ mode="follow_up",
+ )
+ assert agent.session.submit_input(envelope).status == "queued"
+
+ await agent.session._publish_agent_event(
+ MessageEndEvent(
+ message=UserMessage(
+ content=[TextContent(text="forged")],
+ metadata={"input_id": "input-1"},
+ run_id="run-1",
+ )
+ )
+ )
+
+ assert agent.session.cancel_input("input-1").status == "cancelled"
+ release.set()
+ assert await task == "run-1"