Convert continue_as_new chat to workflow update

`user_says` → `turn`, now a `@workflow.update` returning the assistant's
reply directly so callers no longer need a separate `messages` query to
discover what the agent said. The run loop drains in-flight handlers via
`workflow.all_handlers_finished` before continue-as-new.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: brianstrauch

strands_plugin/continue_as_new/README.md

@@ -4,9 +4,10 @@ A chat-style workflow accumulates history with every turn and will eventually hi
 
 ## What This Sample Demonstrates
 
-- Maintaining a multi-turn chat over signals and queries
+- Driving a multi-turn chat with **updates**, so each caller gets the assistant's reply back from the same call
 - Seeding a new `TemporalAgent` with prior `agent.messages`
 - Using `workflow.info().is_continue_as_new_suggested()` + `workflow.continue_as_new(...)` to keep the workflow alive indefinitely
+- Draining in-flight update handlers with `workflow.all_handlers_finished` before continue-as-new
 
 ## Running the Sample
 
@@ -18,12 +19,12 @@ uv run strands_plugin/continue_as_new/run_worker.py
 uv run strands_plugin/continue_as_new/run_workflow.py
 ```
 
-The starter sends a couple of `user_says` signals, queries the message history, then signals `end_chat`. In a real chatbot, a UI would drive the signals and the workflow would run indefinitely, continuing-as-new whenever history gets large.
+The starter calls the `turn` update for each user message and prints the assistant's reply, then signals `end_chat`. In a real chatbot, a UI would drive the updates and the workflow would run indefinitely, continuing-as-new whenever history gets large.
 
 ## Files
 
 | File | Description |
 |------|-------------|
-| `workflow.py` | `ChatInput`, `ChatWorkflow` with `user_says` / `end_chat` signals and `messages` query |
+| `workflow.py` | `ChatInput`, `ChatWorkflow` with `turn` update, `end_chat` signal, and `messages` query |
 | `run_worker.py` | Registers `StrandsPlugin`, starts the worker |
 | `run_workflow.py` | Starts the chat, sends a few turns, ends it |

strands_plugin/continue_as_new/run_workflow.py

@@ -22,15 +22,13 @@ async def main() -> None:
         task_queue="strands-chat",
     )
 
-    await handle.signal(ChatWorkflow.user_says, "Hi! What is durable execution?")
-    await asyncio.sleep(2)
-    await handle.signal(ChatWorkflow.user_says, "Give me a one-sentence summary.")
-    await asyncio.sleep(2)
-
-    messages = await handle.query(ChatWorkflow.messages)
-    print(f"Conversation so far ({len(messages)} messages):")
-    for message in messages:
-        print(f"  {message['role']}: {message['content']}")
+    for prompt in [
+        "Hi! What is durable execution?",
+        "Give me a one-sentence summary.",
+    ]:
+        reply = await handle.execute_update(ChatWorkflow.turn, prompt)
+        print(f"user: {prompt}")
+        print(f"assistant: {reply}\n")
 
     await handle.signal(ChatWorkflow.end_chat)
     await handle.result()

strands_plugin/continue_as_new/workflow.py

@@ -1,10 +1,12 @@
 """Chat-style workflow that continues-as-new before history grows too large.
 
-Every turn appends to ``agent.messages``. Once Temporal suggests
-continue-as-new, the workflow hands the accumulated messages off to a fresh
-run, which seeds a new ``TemporalAgent`` with them and keeps the chat going.
+Each user turn arrives as a Temporal **update**, so the caller gets the
+assistant's reply back from the same call. Once Temporal suggests
+continue-as-new, the workflow drains any in-flight update handlers and hands
+``agent.messages`` off to a fresh run.
 """
 
+import asyncio
 from dataclasses import dataclass, field
 from datetime import timedelta
 
@@ -21,36 +23,41 @@ class ChatInput:
 @workflow.defn
 class ChatWorkflow:
     def __init__(self) -> None:
-        self._pending: list[str] = []
         self._done = False
-        self._messages: Messages = []
-
-    @workflow.signal
-    def user_says(self, prompt: str) -> None:
-        self._pending.append(prompt)
+        self._lock = asyncio.Lock()
+        self._agent: TemporalAgent | None = None
+
+    @workflow.update
+    async def turn(self, prompt: str) -> str:
+        # Updates can arrive before ``run`` has constructed the agent.
+        await workflow.wait_condition(lambda: self._agent is not None)
+        # Serialize turns so concurrent updates can't interleave on ``agent.messages``.
+        async with self._lock:
+            assert self._agent is not None
+            result = await self._agent.invoke_async(prompt)
+            return str(result).strip()
 
     @workflow.signal
     def end_chat(self) -> None:
         self._done = True
 
     @workflow.query
     def messages(self) -> Messages:
-        return list(self._messages)
+        return list(self._agent.messages) if self._agent else []
 
     @workflow.run
     async def run(self, input: ChatInput) -> None:
-        agent = TemporalAgent(
+        self._agent = TemporalAgent(
             start_to_close_timeout=timedelta(seconds=60),
             messages=list(input.messages),
         )
-        self._messages = agent.messages
-
-        while True:
-            await workflow.wait_condition(lambda: bool(self._pending) or self._done)
-            if self._done:
-                return
-            prompt = self._pending.pop(0)
-            await agent.invoke_async(prompt)
-            self._messages = agent.messages
-            if workflow.info().is_continue_as_new_suggested():
-                workflow.continue_as_new(ChatInput(messages=agent.messages))
+
+        await workflow.wait_condition(
+            lambda: self._done or workflow.info().is_continue_as_new_suggested()
+        )
+
+        # Let any in-flight ``turn`` updates finish before we exit or hand off.
+        await workflow.wait_condition(workflow.all_handlers_finished)
+
+        if not self._done:
+            workflow.continue_as_new(ChatInput(messages=self._agent.messages))

tests/strands_plugin/continue_as_new_test.py

@@ -33,13 +33,13 @@ async def test_continue_as_new_chat(
             id=f"strands-chat-{uuid.uuid4()}",
             task_queue=task_queue,
         )
-        await handle.signal(ChatWorkflow.user_says, "Hello")
-        await handle.signal(ChatWorkflow.user_says, "How are you?")
+        reply1 = await handle.execute_update(ChatWorkflow.turn, "Hello")
+        reply2 = await handle.execute_update(ChatWorkflow.turn, "How are you?")
 
-        messages: list = []
-        while len(messages) < 4:
-            messages = await handle.query(ChatWorkflow.messages)
+        assert reply1 == "First reply."
+        assert reply2 == "Second reply."
 
+        messages = await handle.query(ChatWorkflow.messages)
         await handle.signal(ChatWorkflow.end_chat)
         await handle.result()