diff --git a/diagrid/agent/strands/durable_agent.py b/diagrid/agent/strands/durable_agent.py index d89fd8fa..a1ebcf3d 100644 --- a/diagrid/agent/strands/durable_agent.py +++ b/diagrid/agent/strands/durable_agent.py @@ -59,6 +59,10 @@ def search(query: str) -> str: durable = DurableAgent(agent, name="paper-searcher") result = durable("Search for AI papers") ``` + + Like a plain Strands ``Agent``, a ``DurableAgent`` is one conversation: + each call starts from ``agent.messages`` and, when it finishes, writes the + full message list back to ``agent.messages``. """ def __init__( @@ -282,9 +286,10 @@ def agent_workflow(ctx: Any, input_data: dict) -> Generator[Any, Any, dict]: # ) # Build initial messages - messages: list[dict[str, Any]] = [ + messages: list[dict[str, Any]] = list(input_data.get("messages", [])) + [ {"role": "user", "content": [{"text": task}]} ] + completed = False final_text = "" all_tool_calls: list[dict[str, Any]] = [] max_iterations = 10 @@ -316,6 +321,7 @@ def agent_workflow(ctx: Any, input_data: dict) -> Generator[Any, Any, dict]: # # If no tool calls, we're done if not tool_uses or stop_reason == "end_turn": final_text = text + completed = True print( f"[WORKFLOW] Model finished: {stop_reason}", flush=True, @@ -364,6 +370,7 @@ def agent_workflow(ctx: Any, input_data: dict) -> Generator[Any, Any, dict]: # return { # type: ignore[return-value] "result": final_text, "tool_calls": all_tool_calls, + "messages": messages if completed else None, } # Register everything @@ -400,7 +407,7 @@ def __call__(self, task: str, timeout_seconds: int = 120) -> str: # Use the new DaprWorkflowClient API with function reference self._workflow_client.schedule_new_workflow( workflow=self._workflow_func, - input={"task": task}, + input={"task": task, "messages": list(self._agent.messages)}, instance_id=instance_id, ) @@ -434,6 +441,10 @@ def __call__(self, task: str, timeout_seconds: int = 120) -> str: output = json.loads(output) if isinstance(output, dict): + updated = output.get("messages") + if updated is not None: + # Keep the same list object so ``agent.messages`` stays live. + self._agent.messages[:] = updated return output.get("result", str(output)) return str(output) if output else "" diff --git a/diagrid/agent/strands/history.py b/diagrid/agent/strands/history.py new file mode 100644 index 00000000..13050af1 --- /dev/null +++ b/diagrid/agent/strands/history.py @@ -0,0 +1,103 @@ +# Copyright (c) 2026-Present Diagrid Inc. +# SPDX-License-Identifier: BUSL-1.1 + +"""Conversation history for the Strands workflow runner. + +History is keyed by runner name and session id. It lives in a Dapr state store +when one is available, otherwise in a dict inside the runner process. +""" + +import logging +from typing import Any, Optional + +logger = logging.getLogger(__name__) + +# Matches the Strands ``SlidingWindowConversationManager`` default. +DEFAULT_WINDOW_SIZE = 40 + + +def history_key(runner_name: str, session_id: str) -> str: + """Return the state key that holds one session's messages for one runner.""" + return f"strands-{runner_name}-{session_id}-messages" + + +def resolve_window_size(agent: Any) -> int: + """Return how many messages to keep: the agent's sliding window, else 40.""" + try: + from strands.agent.conversation_manager import ( + SlidingWindowConversationManager, + ) + except ImportError: # pragma: no cover - strands is required by this package + return DEFAULT_WINDOW_SIZE + + manager = getattr(agent, "conversation_manager", None) + if isinstance(manager, SlidingWindowConversationManager): + return int(manager.window_size) + return DEFAULT_WINDOW_SIZE + + +def _is_plain_user_message(message: Any) -> bool: + """True for a user message that carries no tool result.""" + if not isinstance(message, dict) or message.get("role") != "user": + return False + content = message.get("content") or [] + return not any(isinstance(b, dict) and "toolResult" in b for b in content) + + +def trim_history(messages: list[Any], window_size: int) -> list[Any]: + """Keep the last ``window_size`` messages, starting at a clean user turn. + + After cutting, messages are dropped from the front until the first one is a + user message without a ``toolResult``. Otherwise a tool result could be left + without the tool call it answers, and the model provider rejects that. + """ + kept = list(messages[-window_size:]) if window_size > 0 else [] + start = 0 + while start < len(kept) and not _is_plain_user_message(kept[start]): + start += 1 + return kept[start:] + + +class HistoryStore: + """Loads and saves session messages for one runner. + + Uses ``state_store`` (a ``DaprStateStore``) when given. Without one, history + is kept in this process and a single warning says it will not survive a + restart or be shared between replicas. + """ + + def __init__(self, runner_name: str, state_store: Optional[Any] = None) -> None: + self._runner_name = runner_name + self._state_store = state_store + self._local: dict[str, list[Any]] = {} + self._warned = False + + def _warn_in_process(self) -> None: + if self._warned: + return + self._warned = True + logger.warning( + "No state store configured for runner %r: conversation history is " + "kept in this process only and will not survive a restart or be " + "shared between replicas. Add a Dapr state component named " + "'agent-memory' (or pass state_store) for durable history.", + self._runner_name, + ) + + def load(self, session_id: str) -> list[Any]: + """Return the stored messages for ``session_id``, or an empty list.""" + key = history_key(self._runner_name, session_id) + if self._state_store is not None: + stored = self._state_store.get(key) + return list(stored) if isinstance(stored, list) else [] + self._warn_in_process() + return list(self._local.get(key, [])) + + def save(self, session_id: str, messages: list[Any]) -> None: + """Store ``messages`` as the full history for ``session_id``.""" + key = history_key(self._runner_name, session_id) + if self._state_store is not None: + self._state_store.save(key, messages) + return + self._warn_in_process() + self._local[key] = list(messages) diff --git a/diagrid/agent/strands/runner.py b/diagrid/agent/strands/runner.py index fc8710aa..d036a2fc 100644 --- a/diagrid/agent/strands/runner.py +++ b/diagrid/agent/strands/runner.py @@ -11,6 +11,7 @@ from diagrid.agent.core.types.type import SupportedFrameworks from diagrid.agent.core.workflow import BaseWorkflowRunner +from .history import HistoryStore, resolve_window_size, trim_history from .workflow import WorkflowOutput if TYPE_CHECKING: @@ -65,6 +66,18 @@ def search_web(query: str) -> str: runner.shutdown() ``` + Conversation history: + ``session_id`` identifies a conversation. Calls with the same + ``session_id`` see the earlier turns, like repeated calls on one plain + Strands ``Agent``; use a new ``session_id`` to start fresh. History is + stored under ``strands---messages``, so runners with + different names never share it. It is saved after each successful run, + trimmed to the agent's ``SlidingWindowConversationManager.window_size`` + (default 40). It goes to the state store (``state_store``, or the + ``agent-memory`` component when present) and survives restarts. Without + one it stays in this process and a warning is logged. The agent's own + ``messages`` and session manager are not used. + Attributes: agent: The Strands Agent to execute workflow_runtime: The Dapr WorkflowRuntime instance @@ -104,6 +117,8 @@ def __init__( state_store=state_store, ) + self._history = HistoryStore(name, self._state_store) + # Register metadata self._register_agent_metadata( agent=self._agent, @@ -121,6 +136,21 @@ def _register_workflow_components(self) -> None: """Set up the workflow runtime, activities, and workflow.""" # Store references for closures agent_ref = self._agent + history = self._history + + # ============================================================ + # Activities: load and save conversation history + # ============================================================ + def load_history_activity(ctx: Any, input_data: dict) -> list: # type: ignore[type-arg] + """Activity that returns the stored messages for a session.""" + return history.load(input_data["session_id"]) + + def save_history_activity(ctx: Any, input_data: dict) -> None: # type: ignore[type-arg] + """Activity that trims and stores the full message list.""" + trimmed = trim_history( + input_data.get("messages", []), resolve_window_size(agent_ref) + ) + history.save(input_data["session_id"], trimmed) # ============================================================ # Activity: Call the model (LLM) @@ -257,11 +287,16 @@ async def _execute() -> Any: def agent_workflow(ctx: Any, input_data: dict) -> Generator[Any, Any, dict]: # type: ignore[type-arg] """Workflow that orchestrates the agent loop.""" task = input_data.get("task", "") + session_id = input_data.get("session_id", "") system_prompt = agent_ref.system_prompt or "" - messages: list[dict[str, Any]] = [ + stored = yield ctx.call_activity( + load_history_activity, input={"session_id": session_id} + ) + messages: list[dict[str, Any]] = list(stored or []) + [ {"role": "user", "content": [{"text": task}]} ] + completed = False final_text = "" all_tool_calls: list[dict[str, Any]] = [] @@ -287,6 +322,7 @@ def agent_workflow(ctx: Any, input_data: dict) -> Generator[Any, Any, dict]: # if not tool_uses or stop_reason == "end_turn": final_text = text + completed = True break tool_results = [] @@ -315,6 +351,12 @@ def agent_workflow(ctx: Any, input_data: dict) -> Generator[Any, Any, dict]: # messages.append({"role": "user", "content": tool_results}) + if completed: + yield ctx.call_activity( + save_history_activity, + input={"session_id": session_id, "messages": messages}, + ) + return { # type: ignore[return-value] "result": final_text, "tool_calls": all_tool_calls, @@ -324,6 +366,12 @@ def agent_workflow(ctx: Any, input_data: dict) -> Generator[Any, Any, dict]: # self._workflow_runtime.register_workflow( agent_workflow, name=self.workflow_name ) + self._workflow_runtime.register_activity( + load_history_activity, name="strands_load_history" + ) + self._workflow_runtime.register_activity( + save_history_activity, name="strands_save_history" + ) self._workflow_runtime.register_activity( call_model_activity, name="strands_call_model" ) @@ -365,7 +413,7 @@ async def run_async( if workflow_id is None: workflow_id = f"strands-{session_id}-{uuid.uuid4().hex[:8]}" - input_data = {"task": task} + input_data = {"task": task, "session_id": session_id} logger.info("Starting workflow: %s", workflow_id) self._workflow_client.schedule_new_workflow( diff --git a/examples/strands/README.md b/examples/strands/README.md index c56573e9..d0d10c02 100644 --- a/examples/strands/README.md +++ b/examples/strands/README.md @@ -76,3 +76,47 @@ Yield workflow events to caller ``` Each workflow activity is checkpointed by Dapr, providing durability guarantees. + +## Conversation history + +`DaprWorkflowAgentRunner` treats `session_id` as one conversation. A second +call with the same `session_id` sees the earlier turns, like repeated calls on +one plain Strands `Agent`. Use a new `session_id` to start fresh. + +```python +runner.run_sync(task="My name is Ada.", session_id="chat-1") +runner.run_sync(task="What is my name?", session_id="chat-1") # sees the first turn +``` + +- History is stored under `strands---messages`, so two + runners with different names never share it. +- It is saved after each successful run and trimmed to the agent's + `SlidingWindowConversationManager.window_size` (default 40). +- For durable memory, add a Dapr state store component named `agent-memory` + (or pass `state_store=` to the runner). History then survives restarts and is + shared between replicas: + + ```yaml + apiVersion: dapr.io/v1alpha1 + kind: Component + metadata: + name: agent-memory + spec: + type: state.redis + version: v1 + metadata: + - name: redisHost + value: "localhost:6379" + - name: redisPassword + value: "" + ``` + +- Without a state store, history stays in the runner process and a warning is + logged: it does not survive a restart and is not shared between replicas. +- The agent's own `messages` and any Strands session manager are not used by + the runner. +- Callers that reuse one fixed `session_id` for unrelated tasks now carry + history between those tasks. + +`DurableAgent` is a single conversation, like `Agent`: each call starts from +`agent.messages` and writes the result back to it. diff --git a/tests/agent/strands_ext/test_durable_agent_history.py b/tests/agent/strands_ext/test_durable_agent_history.py new file mode 100644 index 00000000..25f53f5c --- /dev/null +++ b/tests/agent/strands_ext/test_durable_agent_history.py @@ -0,0 +1,96 @@ +# Copyright (c) 2026-Present Diagrid Inc. +# SPDX-License-Identifier: BUSL-1.1 + +"""DurableAgent keeps conversation history in ``agent.messages``.""" + +import json +from types import SimpleNamespace +from typing import Any +from unittest.mock import MagicMock, patch + +import pytest + +pytest.importorskip("strands") + +from diagrid.agent.strands.durable_agent import DurableAgent # noqa: E402 + + +class _EchoModel: + async def stream(self, messages, tool_specs=None, system_prompt=None, **kwargs): + yield {"messageStart": {"role": "assistant"}} + yield {"contentBlockStart": {"start": {}}} + yield {"contentBlockDelta": {"delta": {"text": f"saw {len(messages)}"}}} + yield {"contentBlockStop": {}} + yield {"messageStop": {"stopReason": "end_turn"}} + + +class _BrokenModel: + async def stream(self, messages, tool_specs=None, system_prompt=None, **kwargs): + raise RuntimeError("boom") + yield # pragma: no cover + + +def _make_durable(model: Any = None) -> tuple[DurableAgent, dict[str, Any], MagicMock]: + agent = SimpleNamespace( + model=model or _EchoModel(), + system_prompt="", + tool_registry=SimpleNamespace(registry={}), + messages=[], + ) + registered: dict[str, Any] = {} + runtime = MagicMock() + runtime.register_workflow.side_effect = lambda fn, name=None: registered.update( + workflow=fn + ) + runtime.register_activity.side_effect = lambda fn, name=None: registered.update( + {name: fn} + ) + client = MagicMock() + durable = DurableAgent(agent=agent, name="chat") # type: ignore[arg-type] + + def _schedule(workflow, input, instance_id): + ctx = SimpleNamespace(call_activity=lambda fn, input=None: (fn, input)) + gen = workflow(ctx, input) + try: + step = next(gen) + while True: + fn, activity_input = step + step = gen.send(fn(None, activity_input)) + except StopIteration as done: + client.state = SimpleNamespace( + runtime_status="COMPLETED", + serialized_output=json.dumps(done.value), + ) + + client.schedule_new_workflow.side_effect = _schedule + client.get_workflow_state.side_effect = lambda instance_id: client.state + + with ( + patch("dapr.ext.workflow.WorkflowRuntime", return_value=runtime), + patch("dapr.ext.workflow.DaprWorkflowClient", return_value=client), + patch("time.sleep"), + ): + durable._initialize_dapr() + return durable, registered, client + + +def test_second_call_sees_first_turn_and_messages_property_shows_it(): + durable, _, _ = _make_durable() + assert durable("hi") == "saw 1" + assert durable("again") == "saw 3" + assert len(durable.messages) == 4 + assert durable.messages[0]["content"][0]["text"] == "hi" + assert durable.messages[-1]["content"][0]["text"] == "saw 3" + + +def test_messages_list_identity_is_preserved(): + durable, _, _ = _make_durable() + before = durable.messages + durable("hi") + assert durable.messages is before + + +def test_failed_model_call_leaves_messages_untouched(): + durable, _, _ = _make_durable(model=_BrokenModel()) + assert durable("hi").startswith("Error:") + assert durable.messages == [] diff --git a/tests/agent/strands_ext/test_history.py b/tests/agent/strands_ext/test_history.py new file mode 100644 index 00000000..b6a99d9f --- /dev/null +++ b/tests/agent/strands_ext/test_history.py @@ -0,0 +1,378 @@ +# Copyright (c) 2026-Present Diagrid Inc. +# SPDX-License-Identifier: BUSL-1.1 + +"""Tests for conversation history in the Strands runner.""" + +import logging +from types import SimpleNamespace +from typing import Any +from unittest.mock import MagicMock, patch + +import pytest + +pytest.importorskip("strands") + +from strands.agent.conversation_manager import ( # noqa: E402 + NullConversationManager, + SlidingWindowConversationManager, +) + +from diagrid.agent.strands.history import ( # noqa: E402 + DEFAULT_WINDOW_SIZE, + HistoryStore, + history_key, + resolve_window_size, + trim_history, +) +from diagrid.agent.strands.runner import DaprWorkflowAgentRunner # noqa: E402 + + +def _user(text: str) -> dict[str, Any]: + return {"role": "user", "content": [{"text": text}]} + + +def _assistant(text: str) -> dict[str, Any]: + return {"role": "assistant", "content": [{"text": text}]} + + +def _tool_use(tool_id: str) -> dict[str, Any]: + return { + "role": "assistant", + "content": [{"toolUse": {"toolUseId": tool_id, "name": "t", "input": {}}}], + } + + +def _tool_result(tool_id: str) -> dict[str, Any]: + return { + "role": "user", + "content": [ + { + "toolResult": { + "toolUseId": tool_id, + "status": "success", + "content": [{"text": "ok"}], + } + } + ], + } + + +class FakeModel: + """Replies with how many messages it received.""" + + def __init__(self) -> None: + self.seen: list[list[Any]] = [] + + async def stream(self, messages, tool_specs=None, system_prompt=None, **kwargs): + self.seen.append(list(messages)) + yield {"messageStart": {"role": "assistant"}} + yield {"contentBlockStart": {"start": {}}} + yield {"contentBlockDelta": {"delta": {"text": f"saw {len(messages)}"}}} + yield {"contentBlockStop": {}} + yield {"messageStop": {"stopReason": "end_turn"}} + + +class FakeStateStore: + store_name = "agent-memory" + + def __init__(self) -> None: + self.data: dict[str, Any] = {} + + def get(self, key: str) -> Any: + return self.data.get(key) + + def save(self, key: str, value: Any, metadata: Any = None) -> None: + self.data[key] = value + + def close(self) -> None: + pass + + +def _make_runner( + name: str = "chat", + *, + state_store: Any = None, + conversation_manager: Any = None, + model: Any = None, +) -> tuple[DaprWorkflowAgentRunner, dict[str, Any], FakeModel]: + model = model or FakeModel() + agent = SimpleNamespace( + model=model, + system_prompt="", + tool_registry=SimpleNamespace(registry={}), + conversation_manager=conversation_manager, + messages=[], + ) + registered: dict[str, Any] = {} + runtime = MagicMock() + runtime.register_workflow.side_effect = lambda fn, name=None: registered.update( + workflow=fn + ) + runtime.register_activity.side_effect = lambda fn, name=None: registered.update( + {name: fn} + ) + with ( + patch( + "diagrid.agent.core.workflow.runner.WorkflowRuntime", return_value=runtime + ), + patch( + "diagrid.agent.core.workflow.runner.discover_components", + return_value=SimpleNamespace(runtime_conf=None, memory_store_name=None), + ), + patch.object(DaprWorkflowAgentRunner, "_register_agent_metadata"), + ): + runner = DaprWorkflowAgentRunner( + agent=agent, + name=name, + state_store=state_store, # type: ignore[arg-type] + ) + return runner, registered, model + + +def _drive(registered: dict[str, Any], task: str, session_id: str) -> dict[str, Any]: + """Run the workflow generator, executing each activity inline.""" + ctx = SimpleNamespace(call_activity=lambda fn, input=None: (fn, input)) + gen = registered["workflow"](ctx, {"task": task, "session_id": session_id}) + try: + step = next(gen) + while True: + fn, activity_input = step + step = gen.send(fn(None, activity_input)) + except StopIteration as done: + return done.value + + +def _drive_all(runner: DaprWorkflowAgentRunner, registered: dict[str, Any], *calls): + return [_drive(registered, task, sid)["result"] for task, sid in calls] + + +class TestTrimHistory: + def test_keeps_everything_under_window(self): + msgs = [_user("a"), _assistant("b")] + assert trim_history(msgs, 10) == msgs + + def test_cuts_to_window_and_starts_on_user(self): + msgs = [_user("1"), _assistant("1"), _user("2"), _assistant("2")] + # Window of 3 starts on an assistant message, which is dropped. + assert trim_history(msgs, 3) == [_user("2"), _assistant("2")] + + def test_drops_orphan_tool_result(self): + msgs = [ + _user("q"), + _tool_use("a"), + _tool_result("a"), + _assistant("done"), + _user("next"), + _assistant("ok"), + ] + # Window of 5 would start at the tool_use; the next clean user turn is "next". + assert trim_history(msgs, 4) == [_user("next"), _assistant("ok")] + trimmed = trim_history(msgs, 5) + assert trimmed[0] == _user("next") + + def test_returns_empty_when_no_clean_user_message(self): + msgs = [_assistant("x"), _tool_use("a"), _tool_result("a")] + assert trim_history(msgs, 3) == [] + + def test_does_not_mutate_input(self): + msgs = [_user("1"), _assistant("1"), _user("2")] + snapshot = list(msgs) + trim_history(msgs, 1) + assert msgs == snapshot + + +class TestWindowSize: + def test_default_without_manager(self): + assert resolve_window_size(SimpleNamespace()) == DEFAULT_WINDOW_SIZE + + def test_sliding_window_size_is_used(self): + agent = SimpleNamespace( + conversation_manager=SlidingWindowConversationManager(window_size=6) + ) + assert resolve_window_size(agent) == 6 + + def test_other_manager_uses_default(self): + agent = SimpleNamespace(conversation_manager=NullConversationManager()) + assert resolve_window_size(agent) == DEFAULT_WINDOW_SIZE + + +class TestHistoryStore: + def test_key_includes_runner_and_session(self): + assert history_key("chat", "s1") == "strands-chat-s1-messages" + + def test_state_store_round_trip(self): + store = FakeStateStore() + history = HistoryStore("chat", store) + assert history.load("s1") == [] + history.save("s1", [_user("hi")]) + assert store.data["strands-chat-s1-messages"] == [_user("hi")] + assert history.load("s1") == [_user("hi")] + + def test_in_process_fallback_warns_once(self, caplog): + history = HistoryStore("chat") + with caplog.at_level(logging.WARNING): + history.load("s1") + history.save("s1", [_user("hi")]) + history.load("s1") + warnings = [r for r in caplog.records if r.levelno == logging.WARNING] + assert len(warnings) == 1 + assert history.load("s1") == [_user("hi")] + + def test_state_store_does_not_warn(self, caplog): + history = HistoryStore("chat", FakeStateStore()) + with caplog.at_level(logging.WARNING): + history.load("s1") + assert not caplog.records + + +class TestRunnerHistory: + def test_second_call_sees_first_turn(self): + runner, registered, model = _make_runner() + first, second = _drive_all(runner, registered, ("hi", "s1"), ("again", "s1")) + assert first == "saw 1" + # user, assistant, user + assert second == "saw 3" + + def test_new_session_starts_empty(self): + runner, registered, _ = _make_runner() + results = _drive_all(runner, registered, ("a", "s1"), ("b", "s1"), ("c", "s2")) + assert results == ["saw 1", "saw 3", "saw 1"] + + def test_history_survives_runner_restart_with_state_store(self): + store = FakeStateStore() + runner1, reg1, _ = _make_runner(state_store=store) + _drive(reg1, "hi", "s1") + runner2, reg2, _ = _make_runner(state_store=store) + assert _drive(reg2, "again", "s1")["result"] == "saw 3" + + def test_runner_names_do_not_share_history(self): + store = FakeStateStore() + _, reg_a, _ = _make_runner("agent-a", state_store=store) + _, reg_b, _ = _make_runner("agent-b", state_store=store) + _drive(reg_a, "hi", "shared") + assert _drive(reg_b, "hi", "shared")["result"] == "saw 1" + assert set(store.data) == { + "strands-agent-a-shared-messages", + "strands-agent-b-shared-messages", + } + + def test_history_is_trimmed_to_window(self): + runner, registered, _ = _make_runner( + conversation_manager=SlidingWindowConversationManager(window_size=4) + ) + results = _drive_all( + runner, + registered, + ("1", "s"), + ("2", "s"), + ("3", "s"), + ("4", "s"), + ) + # Saved history is capped at 4 messages, so the model sees at most 5. + assert results == ["saw 1", "saw 3", "saw 5", "saw 5"] + + def test_agent_messages_are_not_touched(self): + runner, registered, _ = _make_runner() + _drive(registered, "hi", "s1") + assert runner.agent.messages == [] + + def test_failed_model_call_saves_nothing(self): + class BrokenModel: + async def stream(self, **kwargs): + raise RuntimeError("boom") + yield # pragma: no cover + + store = FakeStateStore() + _, registered, _ = _make_runner(state_store=store, model=BrokenModel()) + out = _drive(registered, "hi", "s1") + assert out["result"].startswith("Error:") + assert store.data == {} + + def test_session_id_is_in_workflow_input(self): + runner, _, _ = _make_runner() + runner._started = True + client = MagicMock() + runner._workflow_client = client + runner._poll_workflow = MagicMock() # type: ignore[method-assign] + + async def _empty(*args, **kwargs): + return + yield # pragma: no cover + + runner._poll_workflow = _empty # type: ignore[method-assign] + + import asyncio + + async def _run() -> None: + async for _ in runner.run_async("task", "s-9", workflow_id="wf"): + pass + + asyncio.run(_run()) + sent = client.schedule_new_workflow.call_args.kwargs["input"] + assert sent == {"task": "task", "session_id": "s-9"} + + +class _ToolOnceModel: + """Calls a tool on every new user text turn, then answers in text.""" + + async def stream(self, messages, tool_specs=None, system_prompt=None, **kwargs): + last = messages[-1] + is_tool_turn = any("toolResult" in b for b in last["content"]) + yield {"messageStart": {"role": "assistant"}} + yield {"contentBlockStart": {"start": {}}} + if is_tool_turn: + yield {"contentBlockDelta": {"delta": {"text": "done"}}} + yield {"contentBlockStop": {}} + yield {"messageStop": {"stopReason": "end_turn"}} + return + yield { + "contentBlockStart": { + "start": {"toolUse": {"toolUseId": f"id{len(messages)}", "name": "t"}} + } + } + yield {"contentBlockDelta": {"delta": {"toolUse": {"input": "{}"}}}} + yield {"contentBlockStop": {}} + yield {"messageStop": {"stopReason": "tool_use"}} + + +class TestToolTurnsInHistory: + def test_saved_history_has_no_orphan_tool_result(self): + store = FakeStateStore() + runner, registered, _ = _make_runner( + state_store=store, + conversation_manager=SlidingWindowConversationManager(window_size=6), + model=_ToolOnceModel(), + ) + + class _Tool: + tool_spec = {"name": "t", "description": "d", "inputSchema": {"json": {}}} + + async def stream(self, tool_use, invocation_state): + yield { + "toolUseId": tool_use["toolUseId"], + "status": "success", + "content": [{"text": "ok"}], + } + + runner.agent.tool_registry.registry["t"] = _Tool() + for turn in ("one", "two", "three"): + out = _drive(registered, turn, "s") + assert out["tool_calls"], out + + saved = store.data["strands-chat-s-messages"] + assert len(saved) <= 6 + assert saved[0]["role"] == "user" + assert not any("toolResult" in b for b in saved[0]["content"]) + use_ids = { + b["toolUse"]["toolUseId"] + for m in saved + for b in m["content"] + if "toolUse" in b + } + result_ids = { + b["toolResult"]["toolUseId"] + for m in saved + for b in m["content"] + if "toolResult" in b + } + assert result_ids <= use_ids diff --git a/tests/e2e/test_strands_session_history.py b/tests/e2e/test_strands_session_history.py new file mode 100644 index 00000000..20a3b968 --- /dev/null +++ b/tests/e2e/test_strands_session_history.py @@ -0,0 +1,72 @@ +"""E2E: Strands runner keeps conversation history per ``session_id``. + +Runs against a real Dapr sidecar and its state store. Deterministic, no LLM +required (marked ``integration``, not ``ollama``): the model replies with how +many messages it received, so the second call proves it saw the first turn. +""" + +import uuid +from typing import Any + +import pytest + +from tests.e2e.conftest import clear_dapr_registration + + +class _CountingModel: + """Replies with the number of messages it was given.""" + + # strands.Agent reads this; the base Model class defaults it to False. + stateful = False + + def __init__(self) -> None: + self.seen: list[int] = [] + + async def stream( + self, + messages: Any, + tool_specs: Any = None, + system_prompt: Any = None, + **kw: Any, + ) -> Any: + self.seen.append(len(messages)) + yield {"messageStart": {"role": "assistant"}} + yield {"contentBlockStart": {"start": {}}} + yield {"contentBlockDelta": {"delta": {"text": f"saw {len(messages)}"}}} + yield {"contentBlockStop": {}} + yield {"messageStop": {"stopReason": "end_turn"}} + + +@pytest.mark.integration +def test_second_call_sees_first_turn_via_state_store() -> None: + """Two ``run_sync`` calls with one session_id share history; a new id does not.""" + from strands import Agent + + from diagrid.agent.core.state import DaprStateStore + from diagrid.agent.strands import DaprWorkflowAgentRunner + + clear_dapr_registration() + + model = _CountingModel() + agent = Agent(model=model, tools=[], callback_handler=None) # type: ignore[arg-type] + runner = DaprWorkflowAgentRunner( + agent=agent, + name="e2e-strands-history", + state_store=DaprStateStore(store_name="statestore"), + ) + session = f"e2e-hist-{uuid.uuid4().hex[:8]}" + try: + runner.start() + first = runner.run_sync(task="hello", session_id=session, timeout=60) + second = runner.run_sync(task="again", session_id=session, timeout=60) + other = runner.run_sync(task="fresh", session_id=f"{session}-other", timeout=60) + + assert first is not None and first.result == "saw 1" + # history (user + assistant) plus the new user turn + assert second is not None and second.result == "saw 3", ( + f"second call did not see the first turn: {second}" + ) + assert other is not None and other.result == "saw 1" + finally: + runner.shutdown() + clear_dapr_registration()