agentex-sdk 0.6.1__tar.gz → 0.6.2__tar.gz

agentex_sdk-0.6.2/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.6.2"
+}

{agentex_sdk-0.6.1 → agentex_sdk-0.6.2}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.6.2 (2025-11-05)
+
+Full Changelog: [v0.6.1...v0.6.2](https://github.com/scaleapi/scale-agentex-python/compare/v0.6.1...v0.6.2)
+
+### Features
+
+* **api:** update via SDK Studio ([b732dfa](https://github.com/scaleapi/scale-agentex-python/commit/b732dfac50cacc90c84a751fd6c75d18fa5b43ed))
+
 ## 0.6.1 (2025-11-05)
 
 Full Changelog: [v0.6.0...v0.6.1](https://github.com/scaleapi/scale-agentex-python/compare/v0.6.0...v0.6.1)

{agentex_sdk-0.6.1 → agentex_sdk-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentex-sdk
-Version: 0.6.1
+Version: 0.6.2
 Summary: The official Python library for the agentex API
 Project-URL: Homepage, https://github.com/scaleapi/scale-agentex-python
 Project-URL: Repository, https://github.com/scaleapi/scale-agentex-python

{agentex_sdk-0.6.1 → agentex_sdk-0.6.2}/api.md

@@ -152,3 +152,16 @@ Methods:
 - <code title="get /tracker/{tracker_id}">client.tracker.<a href="./src/agentex/resources/tracker.py">retrieve</a>(tracker_id) -> <a href="./src/agentex/types/agent_task_tracker.py">AgentTaskTracker</a></code>
 - <code title="put /tracker/{tracker_id}">client.tracker.<a href="./src/agentex/resources/tracker.py">update</a>(tracker_id, \*\*<a href="src/agentex/types/tracker_update_params.py">params</a>) -> <a href="./src/agentex/types/agent_task_tracker.py">AgentTaskTracker</a></code>
 - <code title="get /tracker">client.tracker.<a href="./src/agentex/resources/tracker.py">list</a>(\*\*<a href="src/agentex/types/tracker_list_params.py">params</a>) -> <a href="./src/agentex/types/tracker_list_response.py">TrackerListResponse</a></code>
+
+# DeploymentHistory
+
+Types:
+
+```python
+from agentex.types import DeploymentHistory, DeploymentHistoryListResponse
+```
+
+Methods:
+
+- <code title="get /deployment-history/{deployment_id}">client.deployment_history.<a href="./src/agentex/resources/deployment_history.py">retrieve</a>(deployment_id) -> <a href="./src/agentex/types/deployment_history.py">DeploymentHistory</a></code>
+- <code title="get /deployment-history">client.deployment_history.<a href="./src/agentex/resources/deployment_history.py">list</a>(\*\*<a href="src/agentex/types/deployment_history_list_params.py">params</a>) -> <a href="./src/agentex/types/deployment_history_list_response.py">DeploymentHistoryListResponse</a></code>

{agentex_sdk-0.6.1 → agentex_sdk-0.6.2}/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/project/acp.py

@@ -34,6 +34,13 @@ if os.getenv("AGENTEX_DEBUG_ENABLED") == "true":
 
 from agentex.lib.types.fastacp import TemporalACPConfig
 from agentex.lib.sdk.fastacp.fastacp import FastACP
+from agentex.lib.core.temporal.plugins.openai_agents.models.temporal_streaming_model import (
+    TemporalStreamingModelProvider,
+)
+from agentex.lib.core.temporal.plugins.openai_agents.interceptors.context_interceptor import ContextInterceptor
+
+context_interceptor = ContextInterceptor()
+temporal_streaming_model_provider = TemporalStreamingModelProvider()
 
 # Create the ACP server
 acp = FastACP.create(
@@ -44,7 +51,8 @@ acp = FastACP.create(
         # We are also adding the Open AI Agents SDK plugin to the ACP.
         type="temporal",
         temporal_address=os.getenv("TEMPORAL_ADDRESS", "localhost:7233"),
-        plugins=[OpenAIAgentsPlugin()]
+        plugins=[OpenAIAgentsPlugin(model_provider=temporal_streaming_model_provider)],
+        interceptors=[context_interceptor]
     )
 )
 

agentex_sdk-0.6.2/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/project/run_worker.py

@@ -0,0 +1,69 @@
+import asyncio
+
+from temporalio.contrib.openai_agents import OpenAIAgentsPlugin
+
+from project.workflow import ExampleTutorialWorkflow
+from agentex.lib.utils.debug import setup_debug_if_enabled
+from agentex.lib.utils.logging import make_logger
+from agentex.lib.environment_variables import EnvironmentVariables
+from agentex.lib.core.temporal.activities import get_all_activities
+from agentex.lib.core.temporal.workers.worker import AgentexWorker
+from agentex.lib.core.temporal.plugins.openai_agents.models.temporal_streaming_model import (
+    TemporalStreamingModelProvider,
+)
+from agentex.lib.core.temporal.plugins.openai_agents.interceptors.context_interceptor import ContextInterceptor
+
+environment_variables = EnvironmentVariables.refresh()
+
+logger = make_logger(__name__)
+
+
+async def main():
+    # Setup debug mode if enabled
+    setup_debug_if_enabled()
+    
+    task_queue_name = environment_variables.WORKFLOW_TASK_QUEUE
+    if task_queue_name is None:
+        raise ValueError("WORKFLOW_TASK_QUEUE is not set")
+    
+    # Add activities to the worker
+    all_activities = get_all_activities() + []  # add your own activities here
+
+    # ============================================================================
+    # STREAMING SETUP: Interceptor + Model Provider
+    # ============================================================================
+    # This is where the streaming magic is configured! Two key components:
+    #
+    # 1. ContextInterceptor (StreamingInterceptor)
+    #    - 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
+    #    - Still returns complete response to Temporal for determinism/replay safety
+    #    - Uses AgentEx ADK streaming infrastructure (Redis XADD to stream:{task_id})
+    #
+    # Together, these enable real-time LLM streaming while maintaining Temporal's
+    # durability guarantees. No forked components - uses STANDARD OpenAIAgentsPlugin!
+    context_interceptor = ContextInterceptor()
+    temporal_streaming_model_provider = TemporalStreamingModelProvider()
+
+    # Create a worker with automatic tracing
+    # IMPORTANT: We use the STANDARD temporalio.contrib.openai_agents.OpenAIAgentsPlugin
+    # No forking needed! The interceptor + model provider handle all streaming logic.
+    worker = AgentexWorker(
+        task_queue=task_queue_name,
+        plugins=[OpenAIAgentsPlugin(model_provider=temporal_streaming_model_provider)],
+        interceptors=[context_interceptor]
+    )
+
+    await worker.run(
+        activities=all_activities,
+        workflow=ExampleTutorialWorkflow,
+    )
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

{agentex_sdk-0.6.1 → agentex_sdk-0.6.2}/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/project/workflow.py

@@ -18,18 +18,33 @@ KEY CONCEPTS DEMONSTRATED:
 This is the foundation before moving to more advanced patterns with tools and activities.
 """
 
+import os
 import json
+from typing import Any, Dict, List
 
 from agents import Agent, Runner
 from temporalio import workflow
 
 from agentex.lib import adk
 from agentex.lib.types.acp import SendEventParams, CreateTaskParams
+from agentex.lib.types.tracing import SGPTracingProcessorConfig
 from agentex.lib.utils.logging import make_logger
 from agentex.types.text_content import TextContent
+from agentex.lib.utils.model_utils import BaseModel
 from agentex.lib.environment_variables import EnvironmentVariables
 from agentex.lib.core.temporal.types.workflow import SignalName
 from agentex.lib.core.temporal.workflows.workflow import BaseWorkflow
+from agentex.lib.core.tracing.tracing_processor_manager import (
+    add_tracing_processor_config,
+)
+
+# Configure tracing processor (optional - only if you have SGP credentials)
+add_tracing_processor_config(
+    SGPTracingProcessorConfig(
+        sgp_api_key=os.environ.get("SGP_API_KEY", ""),
+        sgp_account_id=os.environ.get("SGP_ACCOUNT_ID", ""),
+    )
+)
 
 environment_variables = EnvironmentVariables.refresh()
 
@@ -39,46 +54,84 @@ if environment_variables.WORKFLOW_NAME is None:
 if environment_variables.AGENT_NAME is None:
     raise ValueError("Environment variable AGENT_NAME is not set")
 
+# Validate OpenAI API key is set
+if not os.environ.get("OPENAI_API_KEY"):
+    raise ValueError(
+        "OPENAI_API_KEY environment variable is not set. "
+        "This tutorial requires an OpenAI API key to run the OpenAI Agents SDK. "
+        "Please set OPENAI_API_KEY in your environment or manifest.yaml file."
+    )
+
 logger = make_logger(__name__)
 
+
+class StateModel(BaseModel):
+    """
+    State model for preserving conversation history across turns.
+
+    This allows the agent to maintain context throughout the conversation,
+    making it possible to reference previous messages and build on the discussion.
+    """
+
+    input_list: List[Dict[str, Any]]
+    turn_number: int
+
+
 @workflow.defn(name=environment_variables.WORKFLOW_NAME)
 class ExampleTutorialWorkflow(BaseWorkflow):
     """
     Hello World Temporal Workflow with OpenAI Agents SDK Integration
-    
+
     This workflow demonstrates the basic pattern for integrating OpenAI Agents SDK
     with Temporal workflows. It shows how agent conversations become durable and
     observable through Temporal's workflow engine.
-    
+
     KEY FEATURES:
     - Durable agent conversations that survive process restarts
     - Automatic activity creation for LLM calls (visible in Temporal UI)
     - Long-running workflows that can handle multiple user interactions
     - Full observability and monitoring through Temporal dashboard
     """
+
     def __init__(self):
         super().__init__(display_name=environment_variables.AGENT_NAME)
         self._complete_task = False
+        self._state: StateModel | None = None
+        self._task_id = None
+        self._trace_id = None
+        self._parent_span_id = None
 
     @workflow.signal(name=SignalName.RECEIVE_EVENT)
     async def on_task_event_send(self, params: SendEventParams) -> None:
         """
         Handle incoming user messages and respond using OpenAI Agents SDK
-        
+
         This signal handler demonstrates the basic integration pattern:
         1. Receive user message through Temporal signal
         2. Echo message back to UI for visibility
         3. Create and run OpenAI agent (automatically becomes a Temporal activity)
         4. Return agent's response to user
-        
+
         TEMPORAL INTEGRATION MAGIC:
-        - When Runner.run() executes, it automatically creates a "invoke_model_activity" 
+        - When Runner.run() executes, it automatically creates a "invoke_model_activity"
         - This activity is visible in Temporal UI with full observability
         - If the LLM call fails, Temporal automatically retries it
         - The entire conversation is durable and survives process restarts
         """
         logger.info(f"Received task message instruction: {params}")
-            
+
+        if self._state is None:
+            raise ValueError("State is not initialized")
+
+        # Increment turn number for tracing
+        self._state.turn_number += 1
+
+        self._task_id = params.task.id
+        self._trace_id = params.task.id
+
+        # Add the user message to conversation history
+        self._state.input_list.append({"role": "user", "content": params.event.content.content})
+
         # ============================================================================
         # STEP 1: Echo User Message
         # ============================================================================
@@ -87,58 +140,81 @@ class ExampleTutorialWorkflow(BaseWorkflow):
         await adk.messages.create(task_id=params.task.id, content=params.event.content)
 
         # ============================================================================
-        # STEP 2: Create OpenAI Agent
+        # STEP 2: Wrap execution in tracing span
         # ============================================================================
-        # Create a simple agent using OpenAI Agents SDK. This agent will respond in haikus
-        # to demonstrate the basic functionality. No tools needed for this hello world example.
-        # 
-        # IMPORTANT: The OpenAI Agents SDK plugin (configured in acp.py and run_worker.py)
-        # automatically converts agent interactions into Temporal activities for durability.
-        
-        
-        agent = Agent(
-            name="Haiku Assistant",
-            instructions="You are a friendly assistant who always responds in the form of a haiku. "
-                        "Each response should be exactly 3 lines following the 5-7-5 syllable pattern.",
-        )
+        # Create a span to track this turn of the conversation
+        async with adk.tracing.span(
+            trace_id=params.task.id,
+            name=f"Turn {self._state.turn_number}",
+            input=self._state.model_dump(),
+        ) as span:
+            self._parent_span_id = span.id if span else None
 
-        # ============================================================================
-        # STEP 3: Run Agent with Temporal Durability
-        # ============================================================================
-        # This is where the magic happens! When Runner.run() executes:
-        # 1. The OpenAI Agents SDK makes LLM calls to generate responses
-        # 2. The plugin automatically wraps these calls as Temporal activities
-        # 3. You'll see "invoke_model_activity" appear in the Temporal UI
-        # 4. If the LLM call fails, Temporal retries it automatically
-        # 5. The conversation state is preserved even if the worker restarts
-        
-        # IMPORTANT NOTE ABOUT AGENT RUN CALLS:
-        # =====================================
-        # Notice that we don't need to wrap the Runner.run() call in an activity!
-        # This might feel weird for anyone who has used Temporal before, as typically 
-        # non-deterministic operations like LLM calls would need to be wrapped in activities.
-        # However, the OpenAI Agents SDK plugin is handling all of this automatically 
-        # behind the scenes.
-        #
-        # Another benefit of this approach is that we don't have to serialize the arguments,
-        # which would typically be the case with Temporal activities - the plugin handles 
-        # all of this for us, making the developer experience much smoother.
-        
-        # Pass the text content directly to Runner.run (it accepts strings)
-        result = await Runner.run(agent, params.event.content.content)
+            # ============================================================================
+            # STEP 3: Create OpenAI Agent
+            # ============================================================================
+            # Create a simple agent using OpenAI Agents SDK. This agent will respond in haikus
+            # to demonstrate the basic functionality. No tools needed for this hello world example.
+            #
+            # IMPORTANT: The OpenAI Agents SDK plugin (configured in acp.py and run_worker.py)
+            # automatically converts agent interactions into Temporal activities for durability.
 
-        # ============================================================================
-        # STEP 4: Send Response Back to User
-        # ============================================================================
-        # Send the agent's response back to the user interface
-        # The agent's haiku response will be displayed in the chat
-        await adk.messages.create(
-            task_id=params.task.id,
-            content=TextContent(
-                author="agent",
-                content=result.final_output,
-            ),
-        )
+            agent = Agent(
+                name="Haiku Assistant",
+                instructions="You are a friendly assistant who always responds in the form of a haiku. "
+                "Each response should be exactly 3 lines following the 5-7-5 syllable pattern.",
+            )
+
+            # ============================================================================
+            # STEP 4: Run Agent with Temporal Durability + Streaming + Conversation History
+            # ============================================================================
+            # This is where the magic happens! When Runner.run() executes:
+            # 1. The OpenAI Agents SDK makes LLM calls to generate responses
+            # 2. The plugin automatically wraps these calls as Temporal activities
+            # 3. You'll see "invoke_model_activity" appear in the Temporal UI
+            # 4. If the LLM call fails, Temporal retries it automatically
+            # 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 model streams tokens in real-time while maintaining determinism
+            # - Complete response is still returned to Temporal for replay safety
+            #
+            # CONVERSATION HISTORY:
+            # - We pass self._state.input_list which contains the full conversation history
+            # - This allows the agent to maintain context across multiple turns
+            # - The agent can reference previous messages and build on the discussion
+
+            # IMPORTANT NOTE ABOUT AGENT RUN CALLS:
+            # =====================================
+            # Notice that we don't need to wrap the Runner.run() call in an activity!
+            # This might feel weird for anyone who has used Temporal before, as typically
+            # non-deterministic operations like LLM calls would need to be wrapped in activities.
+            # However, the OpenAI Agents SDK plugin is handling all of this automatically
+            # behind the scenes.
+            #
+            # Another benefit of this approach is that we don't have to serialize the arguments,
+            # which would typically be the case with Temporal activities - the plugin handles
+            # all of this for us, making the developer experience much smoother.
+
+            # Pass the conversation history to Runner.run to maintain context
+            # The input_list contains all previous messages in OpenAI format
+            result = await Runner.run(agent, self._state.input_list)
+
+            # Update the state with the assistant's response for the next turn
+            # The result contains the full updated conversation including the assistant's response
+            if hasattr(result, "messages") and result.messages:
+                # Extract the assistant message from the result
+                # OpenAI Agents SDK returns the full conversation including the new assistant message
+                for msg in result.messages:
+                    # Add new assistant messages to history
+                    # Skip messages we already have (user messages we just added)
+                    if msg.get("role") == "assistant" and msg not in self._state.input_list:
+                        self._state.input_list.append(msg)
+
+            # Set span output for tracing - include full state
+            span.output = self._state.model_dump()
 
         # ============================================================================
         # WHAT YOU'LL SEE IN TEMPORAL UI:
@@ -159,18 +235,18 @@ class ExampleTutorialWorkflow(BaseWorkflow):
     async def on_task_create(self, params: CreateTaskParams) -> str:
         """
         Temporal Workflow Entry Point - Long-Running Agent Conversation
-        
+
         This method runs when the workflow starts and keeps the agent conversation alive.
         It demonstrates Temporal's ability to run workflows for extended periods (minutes,
         hours, days, or even years) while maintaining full durability.
-        
+
         TEMPORAL WORKFLOW LIFECYCLE:
         1. Workflow starts when a task is created
         2. Sends initial acknowledgment message to user
         3. Waits indefinitely for user messages (handled by on_task_event_send signal)
         4. Each user message triggers the signal handler which runs the OpenAI agent
         5. Workflow continues running until explicitly completed or canceled
-        
+
         DURABILITY BENEFITS:
         - Workflow survives worker restarts, deployments, infrastructure failures
         - All agent conversation history is preserved in Temporal's event store
@@ -179,6 +255,16 @@ class ExampleTutorialWorkflow(BaseWorkflow):
         """
         logger.info(f"Received task create params: {params}")
 
+        # ============================================================================
+        # WORKFLOW INITIALIZATION: Initialize State
+        # ============================================================================
+        # Initialize the conversation state with an empty history
+        # This will be populated as the conversation progresses
+        self._state = StateModel(
+            input_list=[],
+            turn_number=0,
+        )
+
         # ============================================================================
         # WORKFLOW INITIALIZATION: Send Welcome Message
         # ============================================================================
@@ -189,10 +275,10 @@ class ExampleTutorialWorkflow(BaseWorkflow):
             content=TextContent(
                 author="agent",
                 content=f"🌸 Hello! I'm your Haiku Assistant, powered by OpenAI Agents SDK + Temporal! 🌸\n\n"
-                       f"I'll respond to all your messages in beautiful haiku form. "
-                       f"This conversation is now durable - even if I restart, our chat continues!\n\n"
-                       f"Task created with params:\n{json.dumps(params.params, indent=2)}\n\n"
-                       f"Send me a message and I'll respond with a haiku! 🎋",
+                f"I'll respond to all your messages in beautiful haiku form. "
+                f"This conversation is now durable - even if I restart, our chat continues!\n\n"
+                f"Task created with params:\n{json.dumps(params.params, indent=2)}\n\n"
+                f"Send me a message and I'll respond with a haiku! 🎋",
             ),
         )
 
@@ -218,10 +304,10 @@ class ExampleTutorialWorkflow(BaseWorkflow):
     async def complete_task_signal(self) -> None:
         """
         Signal to gracefully complete the agent conversation workflow
-        
+
         This signal can be sent to end the workflow cleanly. In a real application,
         you might trigger this when a user ends the conversation or after a period
         of inactivity.
         """
         logger.info("Received signal to complete the agent conversation")
-        self._complete_task = True
+        self._complete_task = True

{agentex_sdk-0.6.1/examples/tutorials/10_async/10_temporal/080_open_ai_agents_sdk_human_in_the_loop → agentex_sdk-0.6.2/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world}/pyproject.toml

@@ -8,9 +8,10 @@ version = "0.1.0"
 description = "An AgentEx agent"
 requires-python = ">=3.12"
 dependencies = [
-    "agentex-sdk",
+    "agentex-sdk==0.6.0",
+    "openai-agents-sdk==0.4.2",
+    "temporalio==1.18.2",
     "scale-gp",
-    "temporalio>=1.18.0,<2",
 ]
 
 [project.optional-dependencies]

agentex_sdk-0.6.2/examples/tutorials/10_async/10_temporal/060_open_ai_agents_sdk_hello_world/tests/test_agent.py

@@ -0,0 +1,137 @@
+"""
+Sample tests for AgentEx ACP agent.
+
+This test suite demonstrates how to test the main AgentEx API functions:
+- Non-streaming event sending and polling
+- Streaming event sending
+
+To run these tests:
+1. Make sure the agent is running (via docker-compose or `agentex agents run`)
+2. Set the AGENTEX_API_BASE_URL environment variable if not using default
+3. Run: pytest test_agent.py -v
+
+Configuration:
+- AGENTEX_API_BASE_URL: Base URL for the AgentEx server (default: http://localhost:5003)
+- AGENT_NAME: Name of the agent to test (default: example-tutorial)
+"""
+
+import os
+import uuid
+
+import pytest
+import pytest_asyncio
+from test_utils.agentic import (
+    poll_messages,
+    send_event_and_poll_yielding,
+)
+
+from agentex import AsyncAgentex
+from agentex.types.task_message import TaskMessage
+from agentex.types.agent_rpc_params import ParamsCreateTaskRequest
+
+# Configuration from environment variables
+AGENTEX_API_BASE_URL = os.environ.get("AGENTEX_API_BASE_URL", "http://localhost:5003")
+AGENT_NAME = os.environ.get("AGENT_NAME", "example-tutorial")
+
+
+@pytest_asyncio.fixture
+async def client():
+    """Create an AsyncAgentex client instance for testing."""
+    client = AsyncAgentex(base_url=AGENTEX_API_BASE_URL)
+    yield client
+    await client.close()
+
+
+@pytest.fixture
+def agent_name():
+    """Return the agent name for testing."""
+    return AGENT_NAME
+
+
+@pytest_asyncio.fixture
+async def agent_id(client, agent_name):
+    """Retrieve the agent ID based on the agent name."""
+    agents = await client.agents.list()
+    for agent in agents:
+        if agent.name == agent_name:
+            return agent.id
+    raise ValueError(f"Agent with name {agent_name} not found.")
+
+
+class TestNonStreamingEvents:
+    """Test non-streaming event sending and polling."""
+
+    @pytest.mark.asyncio
+    async def test_send_event_and_poll(self, client: AsyncAgentex, agent_id: str):
+        """Test sending an event and polling for the response."""
+        task_response = await client.agents.create_task(agent_id, params=ParamsCreateTaskRequest(name=uuid.uuid1().hex))
+        task = task_response.result
+        assert task is not None
+
+        # Poll for the initial task creation message
+        async for message in poll_messages(
+            client=client,
+            task_id=task.id,
+            timeout=30,
+            sleep_interval=1.0,
+        ):
+            assert isinstance(message, TaskMessage)
+            if message.content and message.content.type == "text" and message.content.author == "agent":
+                # Check for the Haiku Assistant welcome message
+                assert "Haiku Assistant" in message.content.content
+                assert "Temporal" in message.content.content
+                break
+
+        # Send event and poll for response with streaming updates
+        user_message = "Hello how is life?"
+        print(f"[DEBUG 060 POLL] Sending message: '{user_message}'")
+
+        # Use yield_updates=True to get all streaming chunks as they're written
+        final_message = None
+        async for message in send_event_and_poll_yielding(
+            client=client,
+            agent_id=agent_id,
+            task_id=task.id,
+            user_message=user_message,
+            timeout=30,
+            sleep_interval=1.0,
+            yield_updates=True,  # Get updates as streaming writes chunks
+        ):
+            if message.content and message.content.type == "text" and message.content.author == "agent":
+                print(
+                    f"[DEBUG 060 POLL] Received update - Status: {message.streaming_status}, "
+                    f"Content length: {len(message.content.content)}"
+                )
+                final_message = message
+
+                # Stop polling once we get a DONE message
+                if message.streaming_status == "DONE":
+                    print(f"[DEBUG 060 POLL] Streaming complete!")
+                    break
+
+        # Verify the final message has content (the haiku)
+        assert final_message is not None, "Should have received an agent message"
+        assert final_message.content is not None, "Final message should have content"
+        assert len(final_message.content.content) > 0, "Final message should have haiku content"
+
+        print(f"[DEBUG 060 POLL] ✅ Successfully received haiku response!")
+        print(f"[DEBUG 060 POLL] Final haiku:\n{final_message.content.content}")
+        pass
+
+
+class TestStreamingEvents:
+    """Test streaming event sending (backend verification via polling)."""
+
+    @pytest.mark.asyncio
+    async def test_send_event_and_stream(self, client: AsyncAgentex, agent_id: str):
+        """
+        Streaming test placeholder.
+
+        NOTE: SSE streaming is tested via the UI (agentex-ui subscribeTaskState).
+        Backend streaming functionality is verified in test_send_event_and_poll.
+        """
+        pass
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])