Skip to content

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

fix(session): retain input settlement facts

xfgongadfd03e24dc1
diff --git a/cubeloop/agent/agent.py b/cubeloop/agent/agent.py
index a084bfe..4aa73b7 100644
--- a/cubeloop/agent/agent.py
+++ b/cubeloop/agent/agent.py
@@ -366,6 +366,7 @@ class Agent(Generic[TMessage]):
self._state.error_message = None
self._steering_queue.clear()
self._follow_up_queue.clear()
+ self.session._reset_inputs()
self._checkpoint_loaded = False
def _outcome_sink(self) -> Callable[[str], None]:
diff --git a/cubeloop/session/session.py b/cubeloop/session/session.py
index 11b1a81..627899b 100644
--- a/cubeloop/session/session.py
+++ b/cubeloop/session/session.py
@@ -89,6 +89,7 @@ class ExecutionSession:
self._required_delivery_failure: tuple[_Consumer, DeliveryError] | None = None
self._consumers: list[_Consumer] = []
self._input_status: dict[str, InputStatus] = {}
+ self._input_durability: dict[str, InputDurability] = {}
self._queued_inputs: dict[str, Message] = {}
self._delivery_errors: list[DeliveryError] = []
self._turn_contexts: list[TurnExecutionContext] = []
@@ -193,11 +194,7 @@ class ExecutionSession:
def submit_input(self, envelope: InputEnvelope) -> InputReceipt:
existing = self._input_status.get(envelope.input_id)
if existing is not None:
- durability: InputDurability | None = None
- if existing == "committed":
- durability = (
- "checkpoint" if self._has_durable_checkpoint() else "memory"
- )
+ durability = self._input_durability.get(envelope.input_id)
return InputReceipt(
input_id=envelope.input_id,
status=existing,
@@ -222,6 +219,7 @@ class ExecutionSession:
if terminal_id is None:
return InputReceipt(input_id=envelope.input_id, status="closed")
del self._input_status[terminal_id]
+ self._input_durability.pop(terminal_id, None)
message = envelope.message.model_copy(deep=True)
metadata = dict(message.metadata)
@@ -242,13 +240,10 @@ class ExecutionSession:
def cancel_input(self, input_id: str) -> InputReceipt:
status = self._input_status.get(input_id)
if status == "committed":
- durability: InputDurability = (
- "checkpoint" if self._has_durable_checkpoint() else "memory"
- )
return InputReceipt(
input_id=input_id,
status="committed",
- durability=durability,
+ durability=self._input_durability.get(input_id, "memory"),
)
if status == "cancelled":
return InputReceipt(input_id=input_id, status="cancelled")
@@ -263,6 +258,11 @@ class ExecutionSession:
self._queued_inputs.pop(input_id, None)
return InputReceipt(input_id=input_id, status="cancelled")
+ def _reset_inputs(self) -> None:
+ self._input_status.clear()
+ self._input_durability.clear()
+ self._queued_inputs.clear()
+
async def execute(self, request: ExecutionRequest) -> ExecutionResult:
"""Execute one attempt and return settled lifecycle facts."""
self._assert_idle()
@@ -278,9 +278,22 @@ class ExecutionSession:
for input_id, status in tuple(self._input_status.items()):
if status != "queued":
continue
- self._agent._steering_queue.remove(input_id)
- self._agent._follow_up_queue.remove(input_id)
+ removed = self._agent._steering_queue.remove(input_id)
+ removed = self._agent._follow_up_queue.remove(input_id) or removed
+ queued_message = self._queued_inputs.get(input_id)
+ if (
+ not removed
+ and queued_message is not None
+ and any(
+ message is queued_message for message in self._agent.state.messages
+ )
+ ):
+ self._input_status[input_id] = "committed"
+ self._input_durability[input_id] = "memory"
+ self._queued_inputs.pop(input_id, None)
+ continue
del self._input_status[input_id]
+ self._input_durability.pop(input_id, None)
self._queued_inputs.pop(input_id, None)
self._turn_contexts.clear()
self._pending_request = None
@@ -398,6 +411,9 @@ class ExecutionSession:
and self._queued_inputs.get(input_id) is event.message
):
self._input_status[input_id] = "committed"
+ self._input_durability[input_id] = (
+ "checkpoint" if self._has_durable_checkpoint() else "memory"
+ )
self._queued_inputs.pop(input_id, None)
committed_input_id = input_id
await self._publish(event, terminal=False)
@@ -588,7 +604,11 @@ class ExecutionSession:
message=str(caught),
cause=caught,
)
- elif private_outcome == "complete" and not self._agent.state.error_message:
+ elif (
+ history_consistent
+ and private_outcome == "complete"
+ and not self._agent.state.error_message
+ ):
outcome = "completed"
elif self._cancel_requested:
outcome = "cancelled"
diff --git a/tests/agent/test_agent.py b/tests/agent/test_agent.py
index 2ca025e..6b831f2 100644
--- a/tests/agent/test_agent.py
+++ b/tests/agent/test_agent.py
@@ -442,6 +442,18 @@ class TestAgentReset:
assert agent._steering_queue.drain() == []
assert agent._follow_up_queue.drain() == []
+ async def test_reset_clears_session_input_receipts(self):
+ provider = FauxProvider(provider_id="faux")
+ agent = Agent(model=provider.model("faux-1"))
+ agent.session._input_status["input-1"] = "committed"
+ agent.session._input_durability["input-1"] = "memory"
+
+ agent.reset()
+
+ assert agent.session._input_status == {}
+ assert agent.session._input_durability == {}
+ assert agent.session._queued_inputs == {}
+
class TestAgentAbortSignal:
async def test_abort_sets_signal_during_active_run(self):
diff --git a/tests/agent/test_session_input.py b/tests/agent/test_session_input.py
index 6d14ed6..fcf5276 100644
--- a/tests/agent/test_session_input.py
+++ b/tests/agent/test_session_input.py
@@ -569,3 +569,75 @@ async def test_matching_caller_metadata_cannot_commit_an_unrelated_message() ->
assert agent.session.cancel_input("input-1").status == "cancelled"
release.set()
assert await task == "run-1"
+
+
+async def test_append_failure_keeps_drained_input_deduplicated_in_memory() -> None:
+ first_entered = asyncio.Event()
+ release_first = asyncio.Event()
+ second_entered = asyncio.Event()
+ release_second = asyncio.Event()
+
+ class FailingInputCheckpointer(MemoryCheckpointer):
+ async def append(self, thread_id, messages):
+ if any(message.metadata.get("input_id") for message in messages):
+ raise RuntimeError("checkpoint unavailable")
+ await super().append(thread_id, messages)
+
+ async def first_response(messages, model):
+ del messages, model
+ first_entered.set()
+ await release_first.wait()
+ return AssistantMessage(
+ content=[TextContent(text="first")], stop_reason="end_turn"
+ )
+
+ async def second_attempt(messages, model):
+ del messages, model
+ second_entered.set()
+ await release_second.wait()
+ return AssistantMessage(
+ content=[TextContent(text="done")], stop_reason="end_turn"
+ )
+
+ provider = FauxProvider(provider_id="faux")
+ provider.set_responses([first_response, second_attempt])
+ agent = Agent(
+ model=provider.model("faux-model"),
+ checkpointer=FailingInputCheckpointer(),
+ thread_id="thread-1",
+ )
+ first = asyncio.create_task(
+ agent.session.execute(
+ PromptExecutionRequest(
+ run_id="run-1", attempt_id="attempt-1", message="first"
+ )
+ )
+ )
+ await asyncio.wait_for(first_entered.wait(), timeout=1)
+ envelope = InputEnvelope(
+ input_id="input-1",
+ message=UserMessage(content=[TextContent(text="once")]),
+ mode="follow_up",
+ )
+ assert agent.session.submit_input(envelope).status == "queued"
+ release_first.set()
+ first_result = await first
+ assert first_result.outcome == "failed"
+ assert first_result.error is not None
+
+ second = asyncio.create_task(agent.prompt("second", run_id="run-2"))
+ await asyncio.wait_for(second_entered.wait(), timeout=1)
+ duplicate = agent.session.submit_input(envelope)
+
+ assert duplicate.status == "committed"
+ assert duplicate.durability == "memory"
+ assert (
+ sum(
+ message.metadata.get("input_id") == "input-1"
+ for message in agent.state.messages
+ )
+ == 1
+ )
+ release_second.set()
+ assert await second == "run-2"
diff --git a/tests/agent/test_tool_cycle_invariant.py b/tests/agent/test_tool_cycle_invariant.py
index 721f8bf..7e76a13 100644
--- a/tests/agent/test_tool_cycle_invariant.py
+++ b/tests/agent/test_tool_cycle_invariant.py
@@ -19,6 +19,7 @@ from cubeloop.providers.base import (
UserMessage,
)
from cubeloop.providers.faux import FauxProvider
+from cubeloop.session import PromptExecutionRequest
def _asst(call_ids, run_id="R"):
@@ -147,7 +148,11 @@ async def test_incomplete_tool_cycle_does_not_mark():
thread_id="t",
after_model_response=_stop_after,
)
- await a.prompt("hi", run_id="R1")
+ result = await a.session.execute(
+ PromptExecutionRequest(run_id="R1", attempt_id="A1", message="hi")
+ )
+ assert result.outcome == "incomplete"
+ assert result.checkpoint_committed is False
assert cp._runs["t"]["R1"].completed_at is None