fix(openai): retain multi-turn history in 140_harness_openai tutorial [greptile]

The activity created a fresh agent each turn and passed only the latest user
message to Runner.run_streamed, so the model had no memory of prior turns.
Thread the running conversation through the workflow instance (self._messages):
pass the prior input_list into the activity, build [*history, user_message] for
the run, and return result.to_input_list() so the next turn continues the
conversation. The activity now returns RunHarnessAgentResult (final_text +
input_list); the workflow deserializes it via result_type.

Note: the separate 06-22 "usage always empty in the auto_send path" comment is
resolved by the foundation — UnifiedEmitter.auto_send_turn now reads
turn.usage() AFTER auto_send drains the stream (no eager capture).

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

Author: declan-scale

examples/tutorials/10_async/10_temporal/140_harness_openai/project/activities.py

@@ -12,6 +12,8 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 from agents import Runner
 from pydantic import BaseModel
 from temporalio import activity
@@ -31,25 +33,43 @@ class RunHarnessAgentParams(BaseModel):
 
     task_id: str
     user_message: str
+    # Prior conversation as OpenAI Agents SDK input items, so the agent sees the
+    # full history (not just the latest message) on every turn.
+    input_list: list[Any] = []
     trace_id: str | None = None
     parent_span_id: str | None = None
 
 
+class RunHarnessAgentResult(BaseModel):
+    """Result of one harness turn."""
+
+    final_text: str
+    # Updated conversation (prior history + this turn) to carry into the next turn.
+    input_list: list[Any]
+
+
 class HarnessActivities:
     """Hosts the harness-backed OpenAI agent activity."""
 
     @activity.defn(name=RUN_HARNESS_AGENT_ACTIVITY)
-    async def run_harness_openai_agent(self, params: RunHarnessAgentParams) -> str:
-        """Run the agent for one turn and auto-send its output; return final text."""
+    async def run_harness_openai_agent(self, params: RunHarnessAgentParams) -> RunHarnessAgentResult:
+        """Run the agent for one turn and auto-send its output.
+
+        Threads the running conversation through ``input_list`` so multi-turn
+        chats retain memory: prior history + the new user message go in, and the
+        updated conversation comes back out via ``result.to_input_list()``.
+        """
         logger.info(f"Running harness OpenAI agent for task {params.task_id}")
 
         agent = create_agent()
-        result = Runner.run_streamed(starting_agent=agent, input=params.user_message)
+        input_list: list[Any] = [*params.input_list, {"role": "user", "content": params.user_message}]
+        result = Runner.run_streamed(starting_agent=agent, input=input_list)
         turn = OpenAITurn(result=result, model=MODEL_NAME)
         emitter = UnifiedEmitter(
             task_id=params.task_id,
             trace_id=params.trace_id,
             parent_span_id=params.parent_span_id,
         )
         turn_result = await emitter.auto_send_turn(turn)
-        return turn_result.final_text
+        # to_input_list() is valid now: auto_send_turn has exhausted the stream.
+        return RunHarnessAgentResult(final_text=turn_result.final_text, input_list=result.to_input_list())

examples/tutorials/10_async/10_temporal/140_harness_openai/project/workflow.py

@@ -17,7 +17,11 @@
 from temporalio.common import RetryPolicy
 
 from agentex.lib import adk
-from project.activities import RUN_HARNESS_AGENT_ACTIVITY, RunHarnessAgentParams
+from project.activities import (
+    RUN_HARNESS_AGENT_ACTIVITY,
+    RunHarnessAgentParams,
+    RunHarnessAgentResult,
+)
 from agentex.lib.types.acp import SendEventParams, CreateTaskParams
 from agentex.lib.types.tracing import SGPTracingProcessorConfig
 from agentex.lib.utils.logging import make_logger
@@ -53,6 +57,9 @@ def __init__(self):
         super().__init__(display_name=environment_variables.AGENT_NAME)
         self._complete_task = False
         self._turn_number = 0
+        # Running conversation (OpenAI Agents SDK input items) so each turn sees
+        # the full history, not just the latest user message.
+        self._messages: list = []
 
     @workflow.signal(name=SignalName.RECEIVE_EVENT)
     async def on_task_event_send(self, params: SendEventParams) -> None:
@@ -69,19 +76,23 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
             name=f"Turn {self._turn_number}",
             input={"message": params.event.content.content},
         ) as span:
-            final_text = await workflow.execute_activity(
+            turn_result = await workflow.execute_activity(
                 RUN_HARNESS_AGENT_ACTIVITY,
                 RunHarnessAgentParams(
                     task_id=params.task.id,
                     user_message=params.event.content.content,
+                    input_list=self._messages,
                     trace_id=params.task.id,
                     parent_span_id=span.id if span else None,
                 ),
                 start_to_close_timeout=timedelta(minutes=5),
                 retry_policy=RetryPolicy(maximum_attempts=3),
+                result_type=RunHarnessAgentResult,
             )
+            # Carry the updated conversation into the next turn.
+            self._messages = turn_result.input_list
             if span:
-                span.output = {"final_output": final_text}
+                span.output = {"final_output": turn_result.final_text}
 
     @workflow.run
     async def on_task_create(self, params: CreateTaskParams) -> str: