Update tests

danielmillerp · danielmillerp · commit 00601137d242 · 2025-11-06T08:51:59.000-05:00
diff --git a/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/manifest.yaml b/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/manifest.yaml
@@ -96,16 +96,16 @@ agent:
     - env_var_name: REDIS_URL
       secret_name: redis-url-secret
       secret_key: url
-  #   - env_var_name: OPENAI_API_KEY
-  #     secret_name: openai-api-key
-  #     secret_key: api-key
+    # - env_var_name: OPENAI_API_KEY
+    #   secret_name: openai-api-key
+    #   secret_key: api-key
   
   # Optional: Set Environment variables for running your agent locally as well 
   # as for deployment later on
-  env: {}
-    # OPENAI_API_KEY: ""
+  env:
+    OPENAI_API_KEY: ""
     # OPENAI_BASE_URL: "<YOUR_OPENAI_BASE_URL_HERE>"
-    # OPENAI_ORG_ID: ""
+    OPENAI_ORG_ID: ""
 
 
 # Deployment Configuration
diff --git a/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/project/run_worker.py b/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/project/run_worker.py
@@ -34,15 +34,15 @@ async def main():
     # ============================================================================
     # This is where the streaming magic is configured! Two key components:
     #
-    # 1. ContextInterceptor (StreamingInterceptor)
+    # 1. ContextInterceptor
     #    - Threads task_id through activity headers using Temporal's interceptor pattern
     #    - Outbound: Reads _task_id from workflow instance, injects into activity headers
     #    - Inbound: Extracts task_id from headers, sets streaming_task_id ContextVar
     #    - This enables runtime context without forking the Temporal plugin!
     #
     # 2. TemporalStreamingModelProvider
-    #    - Returns StreamingModel instances that read task_id from ContextVar
-    #    - StreamingModel.get_response() streams tokens to Redis in real-time
+    #    - Returns TemporalStreamingModel instances that read task_id from ContextVar
+    #    - TemporalStreamingModel.get_response() streams tokens to Redis in real-time
     #    - Still returns complete response to Temporal for determinism/replay safety
     #    - Uses AgentEx ADK streaming infrastructure (Redis XADD to stream:{task_id})
     #
diff --git a/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/project/workflow.py b/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/project/workflow.py
@@ -176,8 +176,8 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
             # 5. The conversation state is preserved even if the worker restarts
             #
             # STREAMING MAGIC (via Interceptors + Model Provider):
-            # - The StreamingInterceptor threads task_id through activity headers
-            # - The StreamingModelProvider returns a model that streams to Redis
+            # - The ContextInterceptor threads task_id through activity headers
+            # - The TemporalStreamingModelProvider returns a model that streams to Redis
             # - The model streams tokens in real-time while maintaining determinism
             # - Complete response is still returned to Temporal for replay safety
             #
diff --git a/examples/tutorials/10_async/10_temporal/070_open_ai_agents_sdk_tools/manifest.yaml b/examples/tutorials/10_async/10_temporal/070_open_ai_agents_sdk_tools/manifest.yaml
@@ -100,10 +100,10 @@ agent:
 
   # Optional: Set Environment variables for running your agent locally as well 
   # as for deployment later on
-  env: {}
-    # OPENAI_API_KEY: ""
+  env:
+    OPENAI_API_KEY: ""
     # OPENAI_BASE_URL: "<YOUR_OPENAI_BASE_URL_HERE>"
-    # OPENAI_ORG_ID: ""
+    OPENAI_ORG_ID: ""
 
 
 # Deployment Configuration
diff --git a/examples/tutorials/10_async/10_temporal/070_open_ai_agents_sdk_tools/project/run_worker.py b/examples/tutorials/10_async/10_temporal/070_open_ai_agents_sdk_tools/project/run_worker.py
@@ -36,15 +36,15 @@ async def main():
     # ============================================================================
     # This is where the streaming magic is configured! Two key components:
     #
-    # 1. ContextInterceptor (StreamingInterceptor)
+    # 1. ContextInterceptor
     #    - Threads task_id through activity headers using Temporal's interceptor pattern
     #    - Outbound: Reads _task_id from workflow instance, injects into activity headers
     #    - Inbound: Extracts task_id from headers, sets streaming_task_id ContextVar
     #    - This enables runtime context without forking the Temporal plugin!
     #
     # 2. TemporalStreamingModelProvider
-    #    - Returns StreamingModel instances that read task_id from ContextVar
-    #    - StreamingModel.get_response() streams tokens to Redis in real-time
+    #    - Returns TemporalStreamingModel instances that read task_id from ContextVar
+    #    - TemporalStreamingModel.get_response() streams tokens to Redis in real-time
     #    - Still returns complete response to Temporal for determinism/replay safety
     #    - Uses AgentEx ADK streaming infrastructure (Redis XADD to stream:{task_id})
     #
diff --git a/examples/tutorials/10_async/10_temporal/070_open_ai_agents_sdk_tools/project/workflow.py b/examples/tutorials/10_async/10_temporal/070_open_ai_agents_sdk_tools/project/workflow.py
@@ -210,17 +210,17 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
         # ============================================================================
         # STREAMING SETUP: Store task_id for the Interceptor
         # ============================================================================
-        # These instance variables are read by StreamingWorkflowOutboundInterceptor
+        # These instance variables are read by ContextWorkflowOutboundInterceptor
         # which injects them into activity headers. This enables streaming without
         # forking the Temporal plugin!
         #
         # How streaming works (Interceptor + Model Provider + Hooks):
         # 1. We store task_id in workflow instance variable (here)
-        # 2. StreamingWorkflowOutboundInterceptor reads it via workflow.instance()
+        # 2. ContextWorkflowOutboundInterceptor reads it via workflow.instance()
         # 3. Interceptor injects task_id into activity headers
-        # 4. StreamingActivityInboundInterceptor extracts from headers
+        # 4. ContextActivityInboundInterceptor extracts from headers
         # 5. Sets streaming_task_id ContextVar inside the activity
-        # 6. StreamingModel reads from ContextVar and streams to Redis
+        # 6. TemporalStreamingModel reads from ContextVar and streams to Redis
         # 7. TemporalStreamingHooks creates placeholder messages for tool calls
         #
         # This approach uses STANDARD Temporal components - no forked plugin needed!
@@ -237,7 +237,7 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
         # What hooks do:
         # - on_tool_call_start(): Creates tool_request message with arguments
         # - on_tool_call_done(): Creates tool_response message with result
-        # - on_model_stream_part(): Called for each streaming chunk (handled by StreamingModel)
+        # - on_model_stream_part(): Called for each streaming chunk (handled by TemporalStreamingModel)
         # - on_run_done(): Marks the final response as complete
         #
         # These hooks create the messages you see in the test output:
diff --git a/examples/tutorials/10_async/10_temporal/070_open_ai_agents_sdk_tools/tests/test_agent.py b/examples/tutorials/10_async/10_temporal/070_open_ai_agents_sdk_tools/tests/test_agent.py
@@ -99,9 +99,8 @@ async def test_send_event_and_poll(self, client: AsyncAgentex, agent_id: str):
             task_id=task.id,
             user_message=user_message,
             timeout=60,
-            sleep_interval=1.0,
-            yield_updates=True,  # Get all streaming chunks
-        ):
+            sleep_interval=1.0
+            ):
             assert isinstance(message, TaskMessage)
             print(f"[DEBUG 070 POLL] Received message - Type: {message.content.type if message.content else 'None'}, Author: {message.content.author if message.content else 'None'}, Status: {message.streaming_status}")
 
diff --git a/examples/tutorials/10_async/10_temporal/080_open_ai_agents_sdk_human_in_the_loop/manifest.yaml b/examples/tutorials/10_async/10_temporal/080_open_ai_agents_sdk_human_in_the_loop/manifest.yaml
@@ -102,10 +102,10 @@ agent:
   
   # Optional: Set Environment variables for running your agent locally as well
   # as for deployment later on
-  env: {}
-    # OPENAI_API_KEY: ""  # Set this in your shell environment instead
+  env:
+    OPENAI_API_KEY: ""
     # OPENAI_BASE_URL: "<YOUR_OPENAI_BASE_URL_HERE>"
-    # OPENAI_ORG_ID: ""
+    OPENAI_ORG_ID: ""
 
 
 # Deployment Configuration
diff --git a/examples/tutorials/10_async/10_temporal/080_open_ai_agents_sdk_human_in_the_loop/project/acp.py b/examples/tutorials/10_async/10_temporal/080_open_ai_agents_sdk_human_in_the_loop/project/acp.py
@@ -44,15 +44,15 @@
 # ============================================================================
 # This is where the streaming magic is configured! Two key components:
 #
-# 1. ContextInterceptor (StreamingInterceptor)
+# 1. ContextInterceptor
 #    - Threads task_id through activity headers using Temporal's interceptor pattern
 #    - Outbound: Reads _task_id from workflow instance, injects into activity headers
 #    - Inbound: Extracts task_id from headers, sets streaming_task_id ContextVar
 #    - This enables runtime context without forking the Temporal plugin!
 #
 # 2. TemporalStreamingModelProvider
-#    - Returns StreamingModel instances that read task_id from ContextVar
-#    - StreamingModel.get_response() streams tokens to Redis in real-time
+#    - Returns TemporalStreamingModel instances that read task_id from ContextVar
+#    - TemporalStreamingModel.get_response() streams tokens to Redis in real-time
 #    - Still returns complete response to Temporal for determinism/replay safety
 #    - Uses AgentEx ADK streaming infrastructure (Redis XADD to stream:{task_id})
 #
diff --git a/examples/tutorials/10_async/10_temporal/080_open_ai_agents_sdk_human_in_the_loop/project/run_worker.py b/examples/tutorials/10_async/10_temporal/080_open_ai_agents_sdk_human_in_the_loop/project/run_worker.py
@@ -38,15 +38,15 @@ async def main():
     # ============================================================================
     # This is where the streaming magic is configured! Two key components:
     #
-    # 1. ContextInterceptor (StreamingInterceptor)
+    # 1. ContextInterceptor
     #    - Threads task_id through activity headers using Temporal's interceptor pattern
     #    - Outbound: Reads _task_id from workflow instance, injects into activity headers
     #    - Inbound: Extracts task_id from headers, sets streaming_task_id ContextVar
     #    - This enables runtime context without forking the Temporal plugin!
     #
     # 2. TemporalStreamingModelProvider
-    #    - Returns StreamingModel instances that read task_id from ContextVar
-    #    - StreamingModel.get_response() streams tokens to Redis in real-time
+    #    - Returns TemporalStreamingModel instances that read task_id from ContextVar
+    #    - TemporalStreamingModel.get_response() streams tokens to Redis in real-time
     #    - Still returns complete response to Temporal for determinism/replay safety
     #    - Uses AgentEx ADK streaming infrastructure (Redis XADD to stream:{task_id})
     #
diff --git a/examples/tutorials/10_async/10_temporal/080_open_ai_agents_sdk_human_in_the_loop/project/workflow.py b/examples/tutorials/10_async/10_temporal/080_open_ai_agents_sdk_human_in_the_loop/project/workflow.py
@@ -134,17 +134,17 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
         # ============================================================================
         # STREAMING SETUP: Store task_id for the Interceptor
         # ============================================================================
-        # These instance variables are read by StreamingWorkflowOutboundInterceptor
+        # These instance variables are read by ContextWorkflowOutboundInterceptor
         # which injects them into activity headers. This enables streaming without
         # forking the Temporal plugin!
         #
         # How streaming works (Interceptor + Model Provider + Hooks):
         # 1. We store task_id in workflow instance variable (here)
-        # 2. StreamingWorkflowOutboundInterceptor reads it via workflow.instance()
+        # 2. ContextWorkflowOutboundInterceptor reads it via workflow.instance()
         # 3. Interceptor injects task_id into activity headers
-        # 4. StreamingActivityInboundInterceptor extracts from headers
+        # 4. ContextActivityInboundInterceptor extracts from headers
         # 5. Sets streaming_task_id ContextVar inside the activity
-        # 6. StreamingModel reads from ContextVar and streams to Redis
+        # 6. TemporalStreamingModel reads from ContextVar and streams to Redis
         # 7. TemporalStreamingHooks creates placeholder messages for tool calls
         #
         # This approach uses STANDARD Temporal components - no forked plugin needed!
@@ -161,7 +161,7 @@ async def on_task_event_send(self, params: SendEventParams) -> None:
         # What hooks do:
         # - on_tool_call_start(): Creates tool_request message with arguments
         # - on_tool_call_done(): Creates tool_response message with result
-        # - on_model_stream_part(): Called for each streaming chunk (handled by StreamingModel)
+        # - on_model_stream_part(): Called for each streaming chunk (handled by TemporalStreamingModel)
         # - on_run_done(): Marks the final response as complete
         #
         # For human-in-the-loop workflows, hooks create messages showing:
diff --git a/examples/tutorials/run_all_async_tests.sh b/examples/tutorials/run_all_async_tests.sh
@@ -45,9 +45,9 @@ done
 # Find all async tutorial directories
 ALL_TUTORIALS=(
     # sync tutorials
-    #"00_sync/000_hello_acp"
-    #"00_sync/010_multiturn"
-    #"00_sync/020_streaming"
+    "00_sync/000_hello_acp"
+    "00_sync/010_multiturn"
+    "00_sync/020_streaming"
     # base tutorials
     # "10_async/00_base/000_hello_acp"
     # "10_async/00_base/010_multiturn"
diff --git a/examples/tutorials/test_utils/async_utils.py b/examples/tutorials/test_utils/async_utils.py
@@ -25,6 +25,7 @@ async def send_event_and_poll_yielding(
     user_message: str,
     timeout: int = 30,
     sleep_interval: float = 1.0,
+    yield_updates: bool = True,
 ) -> AsyncGenerator[TaskMessage, None]:
     """
     Send an event to an agent and poll for responses, yielding messages as they arrive.
@@ -38,6 +39,7 @@ async def send_event_and_poll_yielding(
         user_message: The message content to send
         timeout: Maximum seconds to wait for a response (default: 30)
         sleep_interval: Seconds to sleep between polls (default: 1.0)
+        yield_updates: If True, yield messages again when their content changes (default: True for streaming)
 
     Yields:
         TaskMessage objects as they are discovered during polling
@@ -61,6 +63,7 @@ async def send_event_and_poll_yielding(
         timeout=timeout,
         sleep_interval=sleep_interval,
         messages_created_after=messages_created_after,
+        yield_updates=yield_updates,
     ):
         yield message
 
@@ -71,9 +74,27 @@ async def poll_messages(
     timeout: int = 30,
     sleep_interval: float = 1.0,
     messages_created_after: Optional[float] = None,
+    yield_updates: bool = False,
 ) -> AsyncGenerator[TaskMessage, None]:
+    """
+    Poll for messages continuously until timeout.
+
+    Args:
+        client: AgentEx client instance
+        task_id: The task ID to poll messages for
+        timeout: Maximum seconds to poll (default: 30)
+        sleep_interval: Seconds to sleep between polls (default: 1.0)
+        messages_created_after: Optional timestamp to filter messages (Unix timestamp)
+        yield_updates: If True, yield messages again when their content changes (for streaming)
+                      If False, only yield each message ID once (default: False)
+
+    Yields:
+        TaskMessage objects as they are discovered or updated
+    """
     # Keep track of messages we've already yielded
     seen_message_ids = set()
+    # Track message content hashes to detect updates (for streaming)
+    message_content_hashes = {}
     start_time = datetime.now()
 
     # Poll continuously until timeout
@@ -89,10 +110,6 @@ async def poll_messages(
 
         new_messages_found = 0
         for message in sorted_messages:
-            # Skip if we've already yielded this message
-            if message.id in seen_message_ids:
-                continue
-
             # Check if message passes timestamp filter
             if messages_created_after and message.created_at:
                 # If message.created_at is timezone-naive, assume it's UTC
@@ -103,14 +120,27 @@ async def poll_messages(
                 if msg_timestamp < messages_created_after:
                     continue
 
-            # Yield new messages that pass the filter
-            seen_message_ids.add(message.id)
-            new_messages_found += 1
-
-            # This yield should transfer control back to the caller
-            yield message
+            # Check if this is a new message or an update to existing message
+            is_new_message = message.id not in seen_message_ids
+
+            if yield_updates:
+                # For streaming: track content changes
+                content_str = message.content.content if message.content and hasattr(message.content, 'content') else ""
+                content_hash = hash(content_str + str(message.streaming_status))
+                is_updated = message.id in message_content_hashes and message_content_hashes[message.id] != content_hash
+
+                if is_new_message or is_updated:
+                    message_content_hashes[message.id] = content_hash
+                    seen_message_ids.add(message.id)
+                    new_messages_found += 1
+                    yield message
+            else:
+                # Original behavior: only yield each message ID once
+                if is_new_message:
+                    seen_message_ids.add(message.id)
+                    new_messages_found += 1
+                    yield message
 
-            # If we see this print, it means the caller consumed the message and we resumed
         # Sleep before next poll
         await asyncio.sleep(sleep_interval)
 

Original file line number	Diff line number	Diff line change
`@@ -34,15 +34,15 @@ async def main():`
`34`	`34`	`# ============================================================================`
`35`	`35`	`# This is where the streaming magic is configured! Two key components:`
`36`	`36`	`#`
`37`		`- # 1. ContextInterceptor (StreamingInterceptor)`
	`37`	`+ # 1. ContextInterceptor`
`38`	`38`	`# - Threads task_id through activity headers using Temporal's interceptor pattern`
`39`	`39`	`# - Outbound: Reads _task_id from workflow instance, injects into activity headers`
`40`	`40`	`# - Inbound: Extracts task_id from headers, sets streaming_task_id ContextVar`
`41`	`41`	`# - This enables runtime context without forking the Temporal plugin!`
`42`	`42`	`#`
`43`	`43`	`# 2. TemporalStreamingModelProvider`
`44`		`- # - Returns StreamingModel instances that read task_id from ContextVar`
`45`		`- # - StreamingModel.get_response() streams tokens to Redis in real-time`
	`44`	`+ # - Returns TemporalStreamingModel instances that read task_id from ContextVar`
	`45`	`+ # - TemporalStreamingModel.get_response() streams tokens to Redis in real-time`
`46`	`46`	`# - Still returns complete response to Temporal for determinism/replay safety`
`47`	`47`	`# - Uses AgentEx ADK streaming infrastructure (Redis XADD to stream:{task_id})`
`48`	`48`	`#`
Original file line number	Diff line number	Diff line change
`@@ -176,8 +176,8 @@ async def on_task_event_send(self, params: SendEventParams) -> None:`
`176`	`176`	`# 5. The conversation state is preserved even if the worker restarts`
`177`	`177`	`#`
`178`	`178`	`# STREAMING MAGIC (via Interceptors + Model Provider):`
`179`		`- # - The StreamingInterceptor threads task_id through activity headers`
`180`		`- # - The StreamingModelProvider returns a model that streams to Redis`
	`179`	`+ # - The ContextInterceptor threads task_id through activity headers`
	`180`	`+ # - The TemporalStreamingModelProvider returns a model that streams to Redis`
`181`	`181`	`# - The model streams tokens in real-time while maintaining determinism`
`182`	`182`	`# - Complete response is still returned to Temporal for replay safety`
`183`	`183`	`#`
Original file line number	Diff line number	Diff line change
`@@ -36,15 +36,15 @@ async def main():`
`36`	`36`	`# ============================================================================`
`37`	`37`	`# This is where the streaming magic is configured! Two key components:`
`38`	`38`	`#`
`39`		`- # 1. ContextInterceptor (StreamingInterceptor)`
	`39`	`+ # 1. ContextInterceptor`
`40`	`40`	`# - Threads task_id through activity headers using Temporal's interceptor pattern`
`41`	`41`	`# - Outbound: Reads _task_id from workflow instance, injects into activity headers`
`42`	`42`	`# - Inbound: Extracts task_id from headers, sets streaming_task_id ContextVar`
`43`	`43`	`# - This enables runtime context without forking the Temporal plugin!`
`44`	`44`	`#`
`45`	`45`	`# 2. TemporalStreamingModelProvider`
`46`		`- # - Returns StreamingModel instances that read task_id from ContextVar`
`47`		`- # - StreamingModel.get_response() streams tokens to Redis in real-time`
	`46`	`+ # - Returns TemporalStreamingModel instances that read task_id from ContextVar`
	`47`	`+ # - TemporalStreamingModel.get_response() streams tokens to Redis in real-time`
`48`	`48`	`# - Still returns complete response to Temporal for determinism/replay safety`
`49`	`49`	`# - Uses AgentEx ADK streaming infrastructure (Redis XADD to stream:{task_id})`
`50`	`50`	`#`
Original file line number	Diff line number	Diff line change
`@@ -44,15 +44,15 @@`
`44`	`44`	`# ============================================================================`
`45`	`45`	`# This is where the streaming magic is configured! Two key components:`
`46`	`46`	`#`
`47`		`-# 1. ContextInterceptor (StreamingInterceptor)`
	`47`	`+# 1. ContextInterceptor`
`48`	`48`	`# - Threads task_id through activity headers using Temporal's interceptor pattern`
`49`	`49`	`# - Outbound: Reads _task_id from workflow instance, injects into activity headers`
`50`	`50`	`# - Inbound: Extracts task_id from headers, sets streaming_task_id ContextVar`
`51`	`51`	`# - This enables runtime context without forking the Temporal plugin!`
`52`	`52`	`#`
`53`	`53`	`# 2. TemporalStreamingModelProvider`
`54`		`-# - Returns StreamingModel instances that read task_id from ContextVar`
`55`		`-# - StreamingModel.get_response() streams tokens to Redis in real-time`
	`54`	`+# - Returns TemporalStreamingModel instances that read task_id from ContextVar`
	`55`	`+# - TemporalStreamingModel.get_response() streams tokens to Redis in real-time`
`56`	`56`	`# - Still returns complete response to Temporal for determinism/replay safety`
`57`	`57`	`# - Uses AgentEx ADK streaming infrastructure (Redis XADD to stream:{task_id})`
`58`	`58`	`#`
Original file line number	Diff line number	Diff line change
`@@ -38,15 +38,15 @@ async def main():`
`38`	`38`	`# ============================================================================`
`39`	`39`	`# This is where the streaming magic is configured! Two key components:`
`40`	`40`	`#`
`41`		`- # 1. ContextInterceptor (StreamingInterceptor)`
	`41`	`+ # 1. ContextInterceptor`
`42`	`42`	`# - Threads task_id through activity headers using Temporal's interceptor pattern`
`43`	`43`	`# - Outbound: Reads _task_id from workflow instance, injects into activity headers`
`44`	`44`	`# - Inbound: Extracts task_id from headers, sets streaming_task_id ContextVar`
`45`	`45`	`# - This enables runtime context without forking the Temporal plugin!`
`46`	`46`	`#`
`47`	`47`	`# 2. TemporalStreamingModelProvider`
`48`		`- # - Returns StreamingModel instances that read task_id from ContextVar`
`49`		`- # - StreamingModel.get_response() streams tokens to Redis in real-time`
	`48`	`+ # - Returns TemporalStreamingModel instances that read task_id from ContextVar`
	`49`	`+ # - TemporalStreamingModel.get_response() streams tokens to Redis in real-time`
`50`	`50`	`# - Still returns complete response to Temporal for determinism/replay safety`
`51`	`51`	`# - Uses AgentEx ADK streaming infrastructure (Redis XADD to stream:{task_id})`
`52`	`52`	`#`