axio 0.5.1__tar.gz → 0.6.0__tar.gz

{axio-0.5.1 → axio-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axio
-Version: 0.5.1
+Version: 0.6.0
 Summary: Minimal, streaming-first, protocol-driven foundation for LLM-powered agents
 Project-URL: Homepage, https://github.com/axio-agent/axio
 Project-URL: Repository, https://github.com/axio-agent/axio

{axio-0.5.1 → axio-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "axio"
-version = "0.5.1"
+version = "0.6.0"
 description = "Minimal, streaming-first, protocol-driven foundation for LLM-powered agents"
 readme = "README.md"
 requires-python = ">=3.12"

{axio-0.5.1 → axio-0.6.0}/src/axio/agent.py

@@ -39,6 +39,7 @@ class Agent:
     tools: list[Tool] = field(default_factory=list)
     selector: ToolSelector | None = field(default=None)
     max_iterations: int = field(default=50)
+    last_iteration_message: Message | None = field(default=None)
 
     def copy(self, **overrides: Any) -> Self:
         """Return a new Agent with *overrides* applied."""
@@ -143,14 +144,19 @@ class Agent:
             for iteration in range(1, self.max_iterations + 1):
                 history = await context.get_history()
                 logger.info("Iteration %d, history length=%d", iteration, len(history))
-                active_tools = list(await self._select_tools(history, self.tools))
+                effective_history = (
+                    [*history, self.last_iteration_message]
+                    if self.last_iteration_message and iteration == self.max_iterations
+                    else history
+                )
+                active_tools = list(await self._select_tools(effective_history, self.tools))
                 content: list[TextBlock | ToolUseBlock] = []
                 pending: dict[str, dict[str, Any]] = {}
                 stop_reason = StopReason.end_turn
                 malformed: set[str] = set()
 
                 try:
-                    async for event in self.transport.stream(history, active_tools, self.system):
+                    async for event in self.transport.stream(effective_history, active_tools, self.system):
                         yield event
                         match event:
                             case TextDelta(delta=delta):

{axio-0.5.1 → axio-0.6.0}/src/axio/messages.py

@@ -10,7 +10,7 @@ from axio.blocks import ContentBlock, from_dict, to_dict
 
 @dataclass(slots=True)
 class Message:
-    role: Literal["user", "assistant"]
+    role: Literal["user", "assistant", "system"]
     content: list[ContentBlock] = field(default_factory=list)
 
     def to_dict(self) -> dict[str, Any]:

{axio-0.5.1 → axio-0.6.0}/tests/test_agent_run.py

@@ -2,14 +2,37 @@
 
 from __future__ import annotations
 
+from collections.abc import AsyncIterator
+
 from axio.agent import Agent
+from axio.blocks import TextBlock
 from axio.context import MemoryContextStore
 from axio.events import IterationEnd, ReasoningDelta, SessionEndEvent, StreamEvent, TextDelta, ToolResult
+from axio.messages import Message
 from axio.testing import MsgInput, StubTransport, make_text_response, make_tool_use_response
 from axio.tool import Tool, ToolHandler
 from axio.types import StopReason, Usage
 
 
+class CapturingTransport:
+    """Records messages passed to each stream() call."""
+
+    def __init__(self, responses: list[list[StreamEvent]]) -> None:
+        self._responses = responses
+        self._call_count = 0
+        self.calls: list[list[Message]] = []
+
+    async def _generate(self, events: list[StreamEvent]) -> AsyncIterator[StreamEvent]:
+        for event in events:
+            yield event
+
+    def stream(self, messages: list[Message], tools: list[Tool], system: str) -> AsyncIterator[StreamEvent]:
+        self.calls.append(list(messages))
+        idx = min(self._call_count, len(self._responses) - 1)
+        self._call_count += 1
+        return self._generate(self._responses[idx])
+
+
 class OkHandler(ToolHandler):
     msg: str
 
@@ -190,3 +213,61 @@ class TestMaxIterations:
         last = events[-1]
         assert isinstance(last, SessionEndEvent)
         assert last.stop_reason == StopReason.error
+
+
+class TestLastIterationMessage:
+    async def test_injected_only_on_last_iteration(self) -> None:
+        """last_iteration_message is appended to history only on the final iteration."""
+        tool = Tool(name="echo", description="echo", handler=OkHandler)
+        hint = Message(role="system", content=[TextBlock(text="wrap up now")])
+        transport = CapturingTransport(
+            [
+                make_tool_use_response("echo", "c1", {"msg": "hi"}, 1),
+                make_text_response("Done", 2),
+            ]
+        )
+        agent = Agent(
+            system="test",
+            tools=[tool],
+            transport=transport,
+            max_iterations=2,
+            last_iteration_message=hint,
+        )
+        await agent.run("go", MemoryContextStore())
+
+        # iteration 1: hint NOT in history
+        assert hint not in transport.calls[0]
+        # iteration 2 (last): hint IS the final message
+        assert transport.calls[1][-1] is hint
+
+    async def test_not_injected_when_none(self) -> None:
+        """No injection when last_iteration_message is None (default)."""
+        transport = CapturingTransport([make_text_response("hi", 1)])
+        agent = Agent(system="test", tools=[], transport=transport)
+        await agent.run("go", MemoryContextStore())
+
+        history = transport.calls[0]
+        assert all(m.role != "system" for m in history)
+
+    async def test_not_stored_in_context(self) -> None:
+        """last_iteration_message is injected into the stream but not persisted."""
+        tool = Tool(name="echo", description="echo", handler=OkHandler)
+        hint = Message(role="system", content=[TextBlock(text="wrap up")])
+        transport = CapturingTransport(
+            [
+                make_tool_use_response("echo", "c1", {"msg": "hi"}, 1),
+                make_text_response("Done", 2),
+            ]
+        )
+        agent = Agent(
+            system="test",
+            tools=[tool],
+            transport=transport,
+            max_iterations=2,
+            last_iteration_message=hint,
+        )
+        context = MemoryContextStore()
+        await agent.run("go", context)
+
+        history = await context.get_history()
+        assert hint not in history