agentex-sdk 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

agentex/lib/sdk/fastacp/tests/test_integration.py

@@ -13,7 +13,7 @@ from agentex.lib.types.acp import (
 )
 from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
 from agentex.lib.sdk.fastacp.impl.temporal_acp import TemporalACP
-from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
+from agentex.lib.sdk.fastacp.impl.async_base_acp import AsyncBaseACP
 
 
 class TestImplementationBehavior:
@@ -29,15 +29,15 @@ class TestImplementationBehavior:
             assert RPCMethod.MESSAGE_SEND in sync_acp._handlers
 
     @pytest.mark.asyncio()
-    async def test_agentic_acp_default_handlers(self):
-        """Test AgenticBaseACP has expected default handlers"""
+    async def test_async_acp_default_handlers(self):
+        """Test AsyncBaseACP has expected default handlers"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            agentic_acp = AgenticBaseACP.create()
+            async_acp = AsyncBaseACP.create()
 
             # Should have create, message, and cancel handlers by default
-            assert RPCMethod.TASK_CREATE in agentic_acp._handlers
-            assert RPCMethod.EVENT_SEND in agentic_acp._handlers
-            assert RPCMethod.TASK_CANCEL in agentic_acp._handlers
+            assert RPCMethod.TASK_CREATE in async_acp._handlers
+            assert RPCMethod.EVENT_SEND in async_acp._handlers
+            assert RPCMethod.TASK_CANCEL in async_acp._handlers
 
     @pytest.mark.asyncio()
     async def test_temporal_acp_creation_with_mocked_client(self):
@@ -114,23 +114,23 @@ class TestRealWorldScenarios:
         await runner.stop()
 
     @pytest.mark.asyncio()
-    async def test_task_lifecycle_management(self, agentic_base_acp, free_port, test_server_runner):
+    async def test_task_lifecycle_management(self, async_base_acp, free_port, test_server_runner):
         """Test complete task lifecycle: create -> message -> cancel"""
         task_events = []
 
-        @agentic_base_acp.on_task_create
+        @async_base_acp.on_task_create
         async def create_handler(params: CreateTaskParams):
             task_events.append(("created", params.task.id))
 
-        @agentic_base_acp.on_task_event_send
+        @async_base_acp.on_task_event_send
         async def message_handler(params: SendEventParams):
             task_events.append(("message", params.task.id))
 
-        @agentic_base_acp.on_task_cancel
+        @async_base_acp.on_task_cancel
         async def cancel_handler(params: CancelTaskParams):
             task_events.append(("cancelled", params.task_id))  # type: ignore[attr-defined]
 
-        runner = test_server_runner(agentic_base_acp, free_port)
+        runner = test_server_runner(async_base_acp, free_port)
         await runner.start()
 
         async with httpx.AsyncClient() as client:
@@ -441,10 +441,10 @@ class TestImplementationIsolation:
         """Test handlers registered on one implementation don't affect others"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
             sync_acp = SyncACP.create()
-            agentic_acp = AgenticBaseACP.create()
+            async_acp = AsyncBaseACP.create()
 
             sync_handled = False
-            agentic_handled = False
+            async_handled = False
 
             @sync_acp.on_task_event_send
             async def sync_handler(params: SendEventParams):
@@ -452,11 +452,11 @@ class TestImplementationIsolation:
                 sync_handled = True
                 return {"sync": True}
 
-            @agentic_acp.on_task_event_send
-            async def agentic_handler(params: SendEventParams):
-                nonlocal agentic_handled
-                agentic_handled = True
-                return {"agentic": True}
+            @async_acp.on_task_event_send
+            async def async_handler(params: SendEventParams):
+                nonlocal async_handled
+                async_handled = True
+                return {"async": True}
 
             # Create test parameters
             message_params = SendEventParams(  # type: ignore[call-arg]
@@ -467,12 +467,12 @@ class TestImplementationIsolation:
             # Execute sync handler
             sync_result = await sync_acp._handlers[RPCMethod.EVENT_SEND](message_params)
             assert sync_handled is True
-            assert agentic_handled is False
+            assert async_handled is False
             assert sync_result == {"sync": True}
 
-            # Reset and execute agentic handler
+            # Reset and execute async handler
             sync_handled = False
-            agentic_result = await agentic_acp._handlers[RPCMethod.EVENT_SEND](message_params)
+            async_result = await async_acp._handlers[RPCMethod.EVENT_SEND](message_params)
             assert sync_handled is False
-            assert agentic_handled is True
-            assert agentic_result == {"agentic": True}
+            assert async_handled is True
+            assert async_result == {"async": True}

agentex/lib/types/fastacp.py

@@ -29,9 +29,9 @@ class SyncACPConfig(BaseACPConfig):
     pass
 
 
-class AgenticACPConfig(BaseACPConfig):
+class AsyncACPConfig(BaseACPConfig):
     """
-    Base class for agentic ACP configurations
+    Base class for async ACP configurations
 
     Attributes:
         type: The type of ACP implementation
@@ -39,8 +39,9 @@ class AgenticACPConfig(BaseACPConfig):
 
     type: Literal["temporal", "base"] = Field(..., frozen=True)
 
+AgenticACPConfig = AsyncACPConfig
 
-class TemporalACPConfig(AgenticACPConfig):
+class TemporalACPConfig(AsyncACPConfig):
     """
     Configuration for TemporalACP implementation
 
@@ -71,11 +72,13 @@ class TemporalACPConfig(AgenticACPConfig):
         return v
 
 
-class AgenticBaseACPConfig(AgenticACPConfig):
-    """Configuration for AgenticBaseACP implementation
+class AsyncBaseACPConfig(AsyncACPConfig):
+    """Configuration for AsyncBaseACP implementation
 
     Attributes:
         type: The type of ACP implementation
     """
 
     type: Literal["base"] = Field(default="base", frozen=True)
+
+AgenticBaseACPConfig = AsyncBaseACPConfig

agentex/lib/utils/dev_tools/async_messages.py

@@ -301,7 +301,7 @@ def subscribe_to_async_task_messages(
             print_task_message(message, print_messages, rich_print)
 
     # Subscribe to server-side events using tasks.stream_events_by_name
-    # This is the proper way to get agent responses after sending an event in agentic agents
+    # This is the proper way to get agent responses after sending an event in async agents
 
     # Ensure task has a name
     if not task.name:

agentex/resources/__init__.py

@@ -56,6 +56,14 @@ from .messages import (
     MessagesResourceWithStreamingResponse,
     AsyncMessagesResourceWithStreamingResponse,
 )
+from .deployment_history import (
+    DeploymentHistoryResource,
+    AsyncDeploymentHistoryResource,
+    DeploymentHistoryResourceWithRawResponse,
+    AsyncDeploymentHistoryResourceWithRawResponse,
+    DeploymentHistoryResourceWithStreamingResponse,
+    AsyncDeploymentHistoryResourceWithStreamingResponse,
+)
 
 __all__ = [
     "AgentsResource",
@@ -100,4 +108,10 @@ __all__ = [
     "AsyncTrackerResourceWithRawResponse",
     "TrackerResourceWithStreamingResponse",
     "AsyncTrackerResourceWithStreamingResponse",
+    "DeploymentHistoryResource",
+    "AsyncDeploymentHistoryResource",
+    "DeploymentHistoryResourceWithRawResponse",
+    "AsyncDeploymentHistoryResourceWithRawResponse",
+    "DeploymentHistoryResourceWithStreamingResponse",
+    "AsyncDeploymentHistoryResourceWithStreamingResponse",
 ]

agentex/resources/deployment_history.py

@@ -0,0 +1,272 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ..types import deployment_history_list_params
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.deployment_history import DeploymentHistory
+from ..types.deployment_history_list_response import DeploymentHistoryListResponse
+
+__all__ = ["DeploymentHistoryResource", "AsyncDeploymentHistoryResource"]
+
+
+class DeploymentHistoryResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> DeploymentHistoryResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers
+        """
+        return DeploymentHistoryResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> DeploymentHistoryResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response
+        """
+        return DeploymentHistoryResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        deployment_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> DeploymentHistory:
+        """
+        Get a deployment record by its unique ID.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not deployment_id:
+            raise ValueError(f"Expected a non-empty value for `deployment_id` but received {deployment_id!r}")
+        return self._get(
+            f"/deployment-history/{deployment_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeploymentHistory,
+        )
+
+    def list(
+        self,
+        *,
+        agent_id: Optional[str] | Omit = omit,
+        agent_name: Optional[str] | Omit = omit,
+        limit: int | Omit = omit,
+        page_number: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> DeploymentHistoryListResponse:
+        """
+        List deployment history for an agent.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get(
+            "/deployment-history",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "agent_id": agent_id,
+                        "agent_name": agent_name,
+                        "limit": limit,
+                        "page_number": page_number,
+                    },
+                    deployment_history_list_params.DeploymentHistoryListParams,
+                ),
+            ),
+            cast_to=DeploymentHistoryListResponse,
+        )
+
+
+class AsyncDeploymentHistoryResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncDeploymentHistoryResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/scaleapi/scale-agentex-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncDeploymentHistoryResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncDeploymentHistoryResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/scaleapi/scale-agentex-python#with_streaming_response
+        """
+        return AsyncDeploymentHistoryResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        deployment_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> DeploymentHistory:
+        """
+        Get a deployment record by its unique ID.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not deployment_id:
+            raise ValueError(f"Expected a non-empty value for `deployment_id` but received {deployment_id!r}")
+        return await self._get(
+            f"/deployment-history/{deployment_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeploymentHistory,
+        )
+
+    async def list(
+        self,
+        *,
+        agent_id: Optional[str] | Omit = omit,
+        agent_name: Optional[str] | Omit = omit,
+        limit: int | Omit = omit,
+        page_number: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> DeploymentHistoryListResponse:
+        """
+        List deployment history for an agent.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._get(
+            "/deployment-history",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "agent_id": agent_id,
+                        "agent_name": agent_name,
+                        "limit": limit,
+                        "page_number": page_number,
+                    },
+                    deployment_history_list_params.DeploymentHistoryListParams,
+                ),
+            ),
+            cast_to=DeploymentHistoryListResponse,
+        )
+
+
+class DeploymentHistoryResourceWithRawResponse:
+    def __init__(self, deployment_history: DeploymentHistoryResource) -> None:
+        self._deployment_history = deployment_history
+
+        self.retrieve = to_raw_response_wrapper(
+            deployment_history.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            deployment_history.list,
+        )
+
+
+class AsyncDeploymentHistoryResourceWithRawResponse:
+    def __init__(self, deployment_history: AsyncDeploymentHistoryResource) -> None:
+        self._deployment_history = deployment_history
+
+        self.retrieve = async_to_raw_response_wrapper(
+            deployment_history.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            deployment_history.list,
+        )
+
+
+class DeploymentHistoryResourceWithStreamingResponse:
+    def __init__(self, deployment_history: DeploymentHistoryResource) -> None:
+        self._deployment_history = deployment_history
+
+        self.retrieve = to_streamed_response_wrapper(
+            deployment_history.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            deployment_history.list,
+        )
+
+
+class AsyncDeploymentHistoryResourceWithStreamingResponse:
+    def __init__(self, deployment_history: AsyncDeploymentHistoryResource) -> None:
+        self._deployment_history = deployment_history
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            deployment_history.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            deployment_history.list,
+        )

agentex/types/__init__.py

@@ -28,6 +28,7 @@ from .state_list_params import StateListParams as StateListParams
 from .agent_rpc_response import AgentRpcResponse as AgentRpcResponse
 from .agent_task_tracker import AgentTaskTracker as AgentTaskTracker
 from .data_content_param import DataContentParam as DataContentParam
+from .deployment_history import DeploymentHistory as DeploymentHistory
 from .span_create_params import SpanCreateParams as SpanCreateParams
 from .span_list_response import SpanListResponse as SpanListResponse
 from .span_update_params import SpanUpdateParams as SpanUpdateParams
@@ -62,4 +63,6 @@ from .task_message_content_param import TaskMessageContentParam as TaskMessageCo
 from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam
 from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam
 from .task_retrieve_by_name_params import TaskRetrieveByNameParams as TaskRetrieveByNameParams
+from .deployment_history_list_params import DeploymentHistoryListParams as DeploymentHistoryListParams
 from .task_retrieve_by_name_response import TaskRetrieveByNameResponse as TaskRetrieveByNameResponse
+from .deployment_history_list_response import DeploymentHistoryListResponse as DeploymentHistoryListResponse

agentex/types/agent.py

@@ -29,13 +29,16 @@ class Agent(BaseModel):
     updated_at: datetime
     """The timestamp when the agent was last updated"""
 
+    agent_input_type: Optional[Literal["text", "json"]] = None
+    """The type of input the agent expects."""
+
     registered_at: Optional[datetime] = None
     """The timestamp when the agent was last registered"""
 
     registration_metadata: Optional[Dict[str, object]] = None
     """The metadata for the agent's registration."""
 
-    status: Optional[Literal["Ready", "Failed", "Unknown", "Deleted"]] = None
+    status: Optional[Literal["Ready", "Failed", "Unknown", "Deleted", "Unhealthy"]] = None
     """The status of the action, indicating if it's building, ready, failed, etc."""
 
     status_reason: Optional[str] = None

agentex/types/deployment_history.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from datetime import datetime
+
+from .._models import BaseModel
+
+__all__ = ["DeploymentHistory"]
+
+
+class DeploymentHistory(BaseModel):
+    id: str
+    """The unique identifier of the deployment record"""
+
+    agent_id: str
+    """The ID of the agent this deployment belongs to"""
+
+    author_email: str
+    """Email of the commit author"""
+
+    author_name: str
+    """Name of the commit author"""
+
+    branch_name: str
+    """Name of the branch"""
+
+    build_timestamp: datetime
+    """When the build was created"""
+
+    commit_hash: str
+    """Git commit hash for this deployment"""
+
+    deployment_timestamp: datetime
+    """When this deployment was first seen in the system"""

agentex/types/deployment_history_list_params.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+__all__ = ["DeploymentHistoryListParams"]
+
+
+class DeploymentHistoryListParams(TypedDict, total=False):
+    agent_id: Optional[str]
+
+    agent_name: Optional[str]
+
+    limit: int
+
+    page_number: int

agentex/types/deployment_history_list_response.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import TypeAlias
+
+from .deployment_history import DeploymentHistory
+
+__all__ = ["DeploymentHistoryListResponse"]
+
+DeploymentHistoryListResponse: TypeAlias = List[DeploymentHistory]

{agentex_sdk-0.6.0.dist-info → agentex_sdk-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentex-sdk
-Version: 0.6.0
+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