agentex-sdk 0.8.1__tar.gz → 0.8.2__tar.gz

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

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

{agentex_sdk-0.8.1 → agentex_sdk-0.8.2}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.8.2 (2026-01-02)
+
+Full Changelog: [v0.8.1...v0.8.2](https://github.com/scaleapi/scale-agentex-python/compare/v0.8.1...v0.8.2)
+
+### Features
+
+* **api:** api update ([f2115eb](https://github.com/scaleapi/scale-agentex-python/commit/f2115ebf273043a87ea50b39837138bfc30a63d6))
+
 ## 0.8.1 (2025-12-22)
 
 Full Changelog: [v0.8.0...v0.8.1](https://github.com/scaleapi/scale-agentex-python/compare/v0.8.0...v0.8.1)

{agentex_sdk-0.8.1 → agentex_sdk-0.8.2}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2025 Agentex
+   Copyright 2026 Agentex
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

{agentex_sdk-0.8.1 → agentex_sdk-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentex-sdk
-Version: 0.8.1
+Version: 0.8.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.8.1 → agentex_sdk-0.8.2}/examples/tutorials/00_sync/020_streaming/tests/test_agent.py

@@ -151,4 +151,3 @@ class TestStreamingMessages:
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])
-

{agentex_sdk-0.8.1 → agentex_sdk-0.8.2}/examples/tutorials/10_async/00_base/000_hello_acp/tests/test_agent.py

@@ -73,6 +73,8 @@ class TestNonStreamingEvents:
         assert task is not None
 
         # Poll for the initial task creation message
+        task_creation_message_found = False
+
         async for message in poll_messages(
             client=client,
             task_id=task.id,
@@ -82,10 +84,15 @@ class TestNonStreamingEvents:
             assert isinstance(message, TaskMessage)
             if message.content and message.content.type == "text" and message.content.author == "agent":
                 assert "Hello! I've received your task" in message.content.content
+                task_creation_message_found = True
                 break
 
+        assert task_creation_message_found, "Task creation message not found"
+
         # Send an event and poll for response
         user_message = "Hello, this is a test message!"
+        agent_response_found = False
+
         async for message in send_event_and_poll_yielding(
             client=client,
             agent_id=agent_id,
@@ -97,9 +104,10 @@ class TestNonStreamingEvents:
             assert isinstance(message, TaskMessage)
             if message.content and message.content.type == "text" and message.content.author == "agent":
                 assert "Hello! I've received your task" in message.content.content
+                agent_response_found = True
                 break
 
-
+        assert agent_response_found, "Agent response not found"
 class TestStreamingEvents:
     """Test streaming event sending."""
 
@@ -111,7 +119,7 @@ class TestStreamingEvents:
 
         assert task is not None
         task_creation_found = False
-        # Poll for the initial task creation message
+
         async for message in poll_messages(
             client=client,
             task_id=task.id,
@@ -124,7 +132,7 @@ class TestStreamingEvents:
                 task_creation_found = True
                 break
 
-        assert task_creation_found, "Task creation message not found in poll"
+        assert task_creation_found, "Task creation message not found"
 
         user_message = "Hello, this is a test message!"
         stream_timeout = 10
@@ -136,9 +144,8 @@ class TestStreamingEvents:
         user_echo_found = False
         agent_response_found = False
 
-        async def collect_stream_events() -> None:
+        async def stream_messages() -> None:
             nonlocal user_echo_found, agent_response_found
-
             async for event in stream_agent_response(
                 client=client,
                 task_id=task.id,
@@ -161,23 +168,19 @@ class TestStreamingEvents:
                         # Check for user message echo
                         if content.get("content") == user_message:
                             user_echo_found = True
+                elif event_type == "done":
+                    break
 
                 # Exit early if we've found all expected messages
                 if user_echo_found and agent_response_found:
                     break
 
-        # Start streaming task
-        stream_task = asyncio.create_task(collect_stream_events())
+        stream_task = asyncio.create_task(stream_messages())
 
         # Send the event
         event_content = TextContentParam(type="text", author="user", content=user_message)
         await client.agents.send_event(agent_id=agent_id, params={"task_id": task.id, "content": event_content})
-
-        # Wait for the stream to complete (with timeout)
-        try:
-            await asyncio.wait_for(stream_task, timeout=stream_timeout)
-        except asyncio.TimeoutError:
-            pytest.fail(f"Stream timed out after {stream_timeout}s waiting for expected messages")
+        await stream_task
 
         # Verify all expected messages were received (fail if stream ended without finding them)
         assert user_echo_found, "User message echo not found in stream"

{agentex_sdk-0.8.1 → agentex_sdk-0.8.2}/examples/tutorials/10_async/00_base/010_multiturn/tests/test_agent.py

@@ -89,6 +89,10 @@ class TestNonStreamingEvents:
 
         user_message = "Hello! Here is my test message"
         messages = []
+
+        # Flags to track what we've received
+        user_message_found = False
+        agent_response_found = False
         async for message in send_event_and_poll_yielding(
             client=client,
             agent_id=agent_id,
@@ -98,17 +102,28 @@ class TestNonStreamingEvents:
             sleep_interval=1.0,
         ):
             messages.append(message)
-            if len(messages) == 1:
-                assert message.content == TextContent(
-                    author="user",
-                    content=user_message,
-                    type="text",
-                )
-            else:
-                assert message.content is not None
-                assert message.content.author == "agent"
+
+            # Validate messages as they arrive
+            if message.content and hasattr(message.content, "author"):
+                msg_text = getattr(message.content, "content", None)
+                if message.content.author == "user" and msg_text == user_message:
+                    assert message.content == TextContent(
+                        author="user",
+                        content=user_message,
+                        type="text",
+                    )
+                    user_message_found = True
+                elif message.content.author == "agent":
+                    assert user_message_found, "Agent response arrived before user message"
+                    agent_response_found = True
+
+            # Exit early if we've found all expected messages
+            if user_message_found and agent_response_found:
                 break
 
+        assert user_message_found, "User message not found"
+        assert agent_response_found, "Agent response not found"
+
         await asyncio.sleep(1)  # wait for state to be updated
         states = await client.states.list(agent_id=agent_id, task_id=task.id)
         assert len(states) == 1
@@ -152,10 +167,8 @@ class TestStreamingEvents:
         # Flags to track what we've received
         user_message_found = False
         agent_response_found = False
-
-        async def stream_messages():
+        async def stream_messages() -> None:
             nonlocal user_message_found, agent_response_found
-
             async for event in stream_agent_response(
                 client=client,
                 task_id=task.id,
@@ -175,21 +188,17 @@ class TestStreamingEvents:
                         # Agent response should come after user message
                         assert user_message_found, "Agent response arrived before user message (incorrect order)"
                         agent_response_found = True
+                elif event_type == "done":
+                    break
 
                 # Exit early if we've found both messages
                 if user_message_found and agent_response_found:
                     break
 
         stream_task = asyncio.create_task(stream_messages())
-
         event_content = TextContentParam(type="text", author="user", content=user_message)
         await client.agents.send_event(agent_id=agent_id, params={"task_id": task.id, "content": event_content})
-
-        # Wait for streaming to complete (with timeout)
-        try:
-            await asyncio.wait_for(stream_task, timeout=15)
-        except asyncio.TimeoutError:
-            pytest.fail("Stream timed out after 15s waiting for expected messages")
+        await stream_task
 
         # Validate we received events
         assert len(all_events) > 0, "No events received in streaming response"

{agentex_sdk-0.8.1 → agentex_sdk-0.8.2}/examples/tutorials/10_async/00_base/020_streaming/tests/test_agent.py

@@ -28,7 +28,6 @@ from test_utils.async_utils import (
 )
 
 from agentex import AsyncAgentex
-from agentex.types import TaskMessage, TextContent
 from agentex.types.agent_rpc_params import ParamsCreateTaskRequest
 from agentex.types.text_content_param import TextContentParam
 
@@ -89,6 +88,10 @@ class TestNonStreamingEvents:
 
         user_message = "Hello! Here is my test message"
         messages = []
+
+        # Flags to track what we've received
+        user_message_found = False
+        agent_response_found = False
         async for message in send_event_and_poll_yielding(
             client=client,
             agent_id=agent_id,
@@ -98,23 +101,25 @@ class TestNonStreamingEvents:
             sleep_interval=1.0,
             yield_updates=False,
         ):
-
             messages.append(message)
 
-        assert len(messages) > 0
-        # the first message should be the agent re-iterating what the user sent
-        assert isinstance(messages, List)
-        assert len(messages) == 2
-        first_message: TaskMessage = messages[0]
-        assert first_message.content == TextContent(
-            author="user",
-            content=user_message,
-            type="text",
-        )
-
-        second_message: TaskMessage = messages[1]
-        assert second_message.content is not None
-        assert second_message.content.author == "agent"
+            # Validate messages as they come in
+            if message.content and hasattr(message.content, "author"):
+                if message.content.author == "user" and message.content.content == user_message:
+                    user_message_found = True
+                elif message.content.author == "agent":
+                    # Agent response should come after user message
+                    assert user_message_found, "Agent response arrived before user message"
+                    agent_response_found = True
+
+            # Exit early if we've found all expected messages
+            if user_message_found and agent_response_found:
+                break
+
+        # Validate we received expected messages
+        assert len(messages) >= 2, "Expected at least 2 messages (user + agent)"
+        assert user_message_found, "User message not found"
+        assert agent_response_found, "Agent response not found"
 
         # assert the state has been updated
         await asyncio.sleep(1)  # wait for state to be updated
@@ -158,7 +163,12 @@ class TestStreamingEvents:
         # Collect events from stream
         all_events = []
 
+        # Flags to track what we've received
+        user_message_found = False
+        full_agent_message_found = False
+        delta_messages_found = False
         async def stream_messages() -> None:
+            nonlocal user_message_found, full_agent_message_found, delta_messages_found
             async for event in stream_agent_response(
                 client=client,
                 task_id=task.id,
@@ -166,33 +176,30 @@ class TestStreamingEvents:
             ):
                 all_events.append(event)
 
-        stream_task = asyncio.create_task(stream_messages())
+                # Check events as they arrive
+                event_type = event.get("type")
+                if event_type == "full":
+                    content = event.get("content", {})
+                    if content.get("content") == user_message and content.get("author") == "user":
+                        user_message_found = True
+                    elif content.get("author") == "agent":
+                        full_agent_message_found = True
+                elif event_type == "delta":
+                    delta_messages_found = True
+                elif event_type == "done":
+                    break
+
+                # Exit early if we've found all expected messages
+                if user_message_found and full_agent_message_found and delta_messages_found:
+                    break
 
+        stream_task = asyncio.create_task(stream_messages())
         event_content = TextContentParam(type="text", author="user", content=user_message)
         await client.agents.send_event(agent_id=agent_id, params={"task_id": task.id, "content": event_content})
-
-        # Wait for streaming to complete
         await stream_task
 
         # Validate we received events
         assert len(all_events) > 0, "No events received in streaming response"
-
-        # Check for user message, full agent response, and delta messages
-        user_message_found = False
-        full_agent_message_found = False
-        delta_messages_found = False
-
-        for event in all_events:
-            event_type = event.get("type")
-            if event_type == "full":
-                content = event.get("content", {})
-                if content.get("content") == user_message and content.get("author") == "user":
-                    user_message_found = True
-                elif content.get("author") == "agent":
-                    full_agent_message_found = True
-            elif event_type == "delta":
-                delta_messages_found = True
-
         assert user_message_found, "User message not found in stream"
         assert full_agent_message_found, "Full agent message not found in stream"
         assert delta_messages_found, "Delta messages not found in stream (streaming response expected)"

{agentex_sdk-0.8.1 → agentex_sdk-0.8.2}/examples/tutorials/10_async/00_base/040_other_sdks/tests/test_agent.py

@@ -94,6 +94,7 @@ class TestNonStreamingEvents:
         # Send a simple message that shouldn't require tool use
         user_message = "Hello! Please introduce yourself briefly."
         messages = []
+        user_message_found = False
         async for message in send_event_and_poll_yielding(
             client=client,
             agent_id=agent_id,
@@ -105,14 +106,17 @@ class TestNonStreamingEvents:
             assert isinstance(message, TaskMessage)
             messages.append(message)
 
-            if len(messages) == 1:
+            if message.content and message.content.author == "user":
                 assert message.content == TextContent(
                     author="user",
                     content=user_message,
                     type="text",
                 )
+                user_message_found = True
                 break
 
+        assert user_message_found, "User message not found"
+
         # Verify state has been updated by polling the states for 10 seconds
         for i in range(20):
             if i == 9:
@@ -140,7 +144,6 @@ class TestNonStreamingEvents:
         tool_request_found = False
         tool_response_found = False
         has_final_agent_response = False
-
         async for message in send_event_and_poll_yielding(
             client=client,
             agent_id=agent_id,
@@ -176,8 +179,10 @@ class TestNonStreamingEvents:
 
         # ensure the task is created before we send the first event
         await asyncio.sleep(1)
+
         # First turn
         user_message_1 = "My favorite color is blue."
+        first_turn_response_found = False
         async for message in send_event_and_poll_yielding(
             client=client,
             agent_id=agent_id,
@@ -193,8 +198,11 @@ class TestNonStreamingEvents:
                 and message.content.author == "agent"
                 and message.content.content
             ):
+                first_turn_response_found = True
                 break
 
+        assert first_turn_response_found, "First turn response not found"
+
         ## keep polling the states for 10 seconds for the input_list and turn_number to be updated
         for i in range(30):
             if i == 29:
@@ -210,9 +218,10 @@ class TestNonStreamingEvents:
         assert state.get("turn_number") == 1
 
         await asyncio.sleep(1)
-        found_response = False
+
         # Second turn - reference previous context
         user_message_2 = "What did I just tell you my favorite color was?"
+        second_turn_response_found = False
         async for message in send_event_and_poll_yielding(
             client=client,
             agent_id=agent_id,
@@ -229,10 +238,10 @@ class TestNonStreamingEvents:
             ):
                 response_text = message.content.content.lower()
                 assert "blue" in response_text
-                found_response = True
+                second_turn_response_found = True
                 break
 
-        assert found_response, "Did not receive final agent text response"
+        assert second_turn_response_found, "Did not receive final agent text response"
         for i in range(10):
             if i == 9:
                 raise Exception("Timeout waiting for state updates")
@@ -271,7 +280,6 @@ class TestStreamingEvents:
         # Collect events from stream
         # Check for user message and delta messages
         user_message_found = False
-
         async def stream_messages() -> None:
             nonlocal user_message_found
             async for event in stream_agent_response(
@@ -291,12 +299,12 @@ class TestStreamingEvents:
                 elif msg_type == "done":
                     break
 
-        stream_task = asyncio.create_task(stream_messages())
+                if user_message_found:
+                    break
 
+        stream_task = asyncio.create_task(stream_messages())
         event_content = TextContentParam(type="text", author="user", content=user_message)
         await client.agents.send_event(agent_id=agent_id, params={"task_id": task.id, "content": event_content})
-
-        # Wait for streaming to complete
         await stream_task
         assert user_message_found, "User message found in stream"
         ## keep polling the states for 10 seconds for the input_list and turn_number to be updated
@@ -333,10 +341,7 @@ class TestStreamingEvents:
         tool_requests_seen = []
         tool_responses_seen = []
         text_deltas_seen = []
-
         async def stream_messages() -> None:
-            nonlocal tool_requests_seen, tool_responses_seen, text_deltas_seen
-
             async for event in stream_agent_response(
                 client=client,
                 task_id=task.id,
@@ -378,11 +383,8 @@ class TestStreamingEvents:
                     break
 
         stream_task = asyncio.create_task(stream_messages())
-
         event_content = TextContentParam(type="text", author="user", content=user_message)
         await client.agents.send_event(agent_id=agent_id, params={"task_id": task.id, "content": event_content})
-
-        # Wait for streaming to complete
         await stream_task
 
         # Verify we saw tool usage (if the agent decided to use tools)

{agentex_sdk-0.8.1 → agentex_sdk-0.8.2}/examples/tutorials/10_async/00_base/080_batch_events/tests/test_agent.py

@@ -75,6 +75,7 @@ class TestNonStreamingEvents:
 
         # Send an event and poll for response using the helper function
         # there should only be one message returned about batching
+        agent_response_found = False
         async for message in send_event_and_poll_yielding(
             client=client,
             agent_id=agent_id,
@@ -84,10 +85,13 @@ class TestNonStreamingEvents:
             sleep_interval=1.0,
         ):
             assert isinstance(message, TaskMessage)
-            assert isinstance(message.content, TextContent)
-            assert "Processed event IDs" in message.content.content
-            assert message.content.author == "agent"
-            break
+            if message.content and message.content.author == "agent":
+                assert isinstance(message.content, TextContent)
+                assert "Processed event IDs" in message.content.content
+                agent_response_found = True
+                break
+
+        assert agent_response_found, "Agent response not found"
 
     @pytest.mark.asyncio
     async def test_send_multiple_events_batched(self, client: AsyncAgentex, agent_id: str):
@@ -159,6 +163,33 @@ class TestStreamingEvents:
         task = task_response.result
         assert task is not None
 
+        # Stream the responses and collect agent messages
+        print("\nStreaming batch responses...")
+
+        # We'll collect all agent messages from the stream
+        agent_messages = []
+        stream_timeout = 90  # Longer timeout for 20 events
+        async def stream_messages() -> None:
+            async for event in stream_agent_response(
+                client=client,
+                task_id=task.id,
+                timeout=stream_timeout,
+            ):
+                # Collect agent text messages
+                if event.get("type") == "full":
+                    content = event.get("content", {})
+                    if content.get("type") == "text" and content.get("author") == "agent":
+                        msg_content = content.get("content", "")
+                        if msg_content and msg_content.strip():
+                            agent_messages.append(msg_content)
+                elif event.get("type") == "done":
+                    break
+
+                if len(agent_messages) >= 2:
+                    break
+
+        stream_task = asyncio.create_task(stream_messages())
+
         # Send 10 events in quick succession (should be batched)
         num_events = 10
         print(f"\nSending {num_events} events in quick succession...")
@@ -167,28 +198,7 @@ class TestStreamingEvents:
             await client.agents.send_event(agent_id=agent_id, params={"task_id": task.id, "content": event_content})
             await asyncio.sleep(0.1)  # Small delay to ensure ordering
 
-        # Stream the responses and collect agent messages
-        print("\nStreaming batch responses...")
-
-        # We'll collect all agent messages from the stream
-        agent_messages = []
-        stream_timeout = 90  # Longer timeout for 20 events
-
-        async for event in stream_agent_response(
-            client=client,
-            task_id=task.id,
-            timeout=stream_timeout,
-        ):
-            # Collect agent text messages
-            if event.get("type") == "full":
-                content = event.get("content", {})
-                if content.get("type") == "text" and content.get("author") == "agent":
-                    msg_content = content.get("content", "")
-                    if msg_content and msg_content.strip():
-                        agent_messages.append(msg_content)
-
-            if len(agent_messages) >= 2:
-                break
+        await stream_task
 
         print(f"\nSent {num_events} events")
         print(f"Received {len(agent_messages)} agent response(s)")