agentex-sdk 0.1.0a6__py3-none-any.whl

agentex/resources/tracker.py

@@ -0,0 +1,384 @@
+# 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 tracker_list_params, tracker_update_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.agent_task_tracker import AgentTaskTracker
+from ..types.tracker_list_response import TrackerListResponse
+
+__all__ = ["TrackerResource", "AsyncTrackerResource"]
+
+
+class TrackerResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> TrackerResourceWithRawResponse:
+        """
+        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/agentex-python#accessing-raw-response-data-eg-headers
+        """
+        return TrackerResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TrackerResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response
+        """
+        return TrackerResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        tracker_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,
+    ) -> AgentTaskTracker:
+        """
+        Get agent task tracker by tracker 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 tracker_id:
+            raise ValueError(f"Expected a non-empty value for `tracker_id` but received {tracker_id!r}")
+        return self._get(
+            f"/tracker/{tracker_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=AgentTaskTracker,
+        )
+
+    def update(
+        self,
+        tracker_id: str,
+        *,
+        last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN,
+        status: Optional[str] | NotGiven = NOT_GIVEN,
+        status_reason: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> AgentTaskTracker:
+        """
+        Update agent task tracker by tracker ID
+
+        Args:
+          last_processed_event_id: The most recent processed event ID (omit to leave unchanged)
+
+          status: Processing status
+
+          status_reason: Optional status reason
+
+          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 tracker_id:
+            raise ValueError(f"Expected a non-empty value for `tracker_id` but received {tracker_id!r}")
+        return self._put(
+            f"/tracker/{tracker_id}",
+            body=maybe_transform(
+                {
+                    "last_processed_event_id": last_processed_event_id,
+                    "status": status,
+                    "status_reason": status_reason,
+                },
+                tracker_update_params.TrackerUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=AgentTaskTracker,
+        )
+
+    def list(
+        self,
+        *,
+        agent_id: Optional[str] | NotGiven = NOT_GIVEN,
+        task_id: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TrackerListResponse:
+        """
+        List all agent task trackers, optionally filtered by query parameters.
+
+        Args:
+          agent_id: Agent ID
+
+          task_id: Task ID
+
+          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(
+            "/tracker",
+            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,
+                        "task_id": task_id,
+                    },
+                    tracker_list_params.TrackerListParams,
+                ),
+            ),
+            cast_to=TrackerListResponse,
+        )
+
+
+class AsyncTrackerResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncTrackerResourceWithRawResponse:
+        """
+        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/agentex-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncTrackerResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTrackerResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/scaleapi/agentex-python#with_streaming_response
+        """
+        return AsyncTrackerResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        tracker_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,
+    ) -> AgentTaskTracker:
+        """
+        Get agent task tracker by tracker 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 tracker_id:
+            raise ValueError(f"Expected a non-empty value for `tracker_id` but received {tracker_id!r}")
+        return await self._get(
+            f"/tracker/{tracker_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=AgentTaskTracker,
+        )
+
+    async def update(
+        self,
+        tracker_id: str,
+        *,
+        last_processed_event_id: Optional[str] | NotGiven = NOT_GIVEN,
+        status: Optional[str] | NotGiven = NOT_GIVEN,
+        status_reason: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> AgentTaskTracker:
+        """
+        Update agent task tracker by tracker ID
+
+        Args:
+          last_processed_event_id: The most recent processed event ID (omit to leave unchanged)
+
+          status: Processing status
+
+          status_reason: Optional status reason
+
+          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 tracker_id:
+            raise ValueError(f"Expected a non-empty value for `tracker_id` but received {tracker_id!r}")
+        return await self._put(
+            f"/tracker/{tracker_id}",
+            body=await async_maybe_transform(
+                {
+                    "last_processed_event_id": last_processed_event_id,
+                    "status": status,
+                    "status_reason": status_reason,
+                },
+                tracker_update_params.TrackerUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=AgentTaskTracker,
+        )
+
+    async def list(
+        self,
+        *,
+        agent_id: Optional[str] | NotGiven = NOT_GIVEN,
+        task_id: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TrackerListResponse:
+        """
+        List all agent task trackers, optionally filtered by query parameters.
+
+        Args:
+          agent_id: Agent ID
+
+          task_id: Task ID
+
+          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(
+            "/tracker",
+            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,
+                        "task_id": task_id,
+                    },
+                    tracker_list_params.TrackerListParams,
+                ),
+            ),
+            cast_to=TrackerListResponse,
+        )
+
+
+class TrackerResourceWithRawResponse:
+    def __init__(self, tracker: TrackerResource) -> None:
+        self._tracker = tracker
+
+        self.retrieve = to_raw_response_wrapper(
+            tracker.retrieve,
+        )
+        self.update = to_raw_response_wrapper(
+            tracker.update,
+        )
+        self.list = to_raw_response_wrapper(
+            tracker.list,
+        )
+
+
+class AsyncTrackerResourceWithRawResponse:
+    def __init__(self, tracker: AsyncTrackerResource) -> None:
+        self._tracker = tracker
+
+        self.retrieve = async_to_raw_response_wrapper(
+            tracker.retrieve,
+        )
+        self.update = async_to_raw_response_wrapper(
+            tracker.update,
+        )
+        self.list = async_to_raw_response_wrapper(
+            tracker.list,
+        )
+
+
+class TrackerResourceWithStreamingResponse:
+    def __init__(self, tracker: TrackerResource) -> None:
+        self._tracker = tracker
+
+        self.retrieve = to_streamed_response_wrapper(
+            tracker.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            tracker.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            tracker.list,
+        )
+
+
+class AsyncTrackerResourceWithStreamingResponse:
+    def __init__(self, tracker: AsyncTrackerResource) -> None:
+        self._tracker = tracker
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            tracker.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            tracker.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            tracker.list,
+        )

agentex/types/__init__.py

@@ -0,0 +1,56 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .span import Span as Span
+from .task import Task as Task
+from .agent import Agent as Agent
+from .event import Event as Event
+from .state import State as State
+from .shared import TaskMessageUpdate as TaskMessageUpdate
+from .acp_type import AcpType as AcpType
+from .data_delta import DataDelta as DataDelta
+from .text_delta import TextDelta as TextDelta
+from .data_content import DataContent as DataContent
+from .task_message import TaskMessage as TaskMessage
+from .text_content import TextContent as TextContent
+from .message_style import MessageStyle as MessageStyle
+from .message_author import MessageAuthor as MessageAuthor
+from .agent_rpc_params import AgentRpcParams as AgentRpcParams
+from .agent_rpc_result import AgentRpcResult as AgentRpcResult
+from .span_list_params import SpanListParams as SpanListParams
+from .agent_list_params import AgentListParams as AgentListParams
+from .event_list_params import EventListParams as EventListParams
+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 .span_create_params import SpanCreateParams as SpanCreateParams
+from .span_list_response import SpanListResponse as SpanListResponse
+from .span_update_params import SpanUpdateParams as SpanUpdateParams
+from .task_list_response import TaskListResponse as TaskListResponse
+from .task_message_delta import TaskMessageDelta as TaskMessageDelta
+from .text_content_param import TextContentParam as TextContentParam
+from .tool_request_delta import ToolRequestDelta as ToolRequestDelta
+from .agent_list_response import AgentListResponse as AgentListResponse
+from .event_list_response import EventListResponse as EventListResponse
+from .message_list_params import MessageListParams as MessageListParams
+from .state_create_params import StateCreateParams as StateCreateParams
+from .state_list_response import StateListResponse as StateListResponse
+from .state_update_params import StateUpdateParams as StateUpdateParams
+from .tool_response_delta import ToolResponseDelta as ToolResponseDelta
+from .tracker_list_params import TrackerListParams as TrackerListParams
+from .task_delete_response import TaskDeleteResponse as TaskDeleteResponse
+from .task_message_content import TaskMessageContent as TaskMessageContent
+from .tool_request_content import ToolRequestContent as ToolRequestContent
+from .message_create_params import MessageCreateParams as MessageCreateParams
+from .message_list_response import MessageListResponse as MessageListResponse
+from .message_update_params import MessageUpdateParams as MessageUpdateParams
+from .tool_response_content import ToolResponseContent as ToolResponseContent
+from .tracker_list_response import TrackerListResponse as TrackerListResponse
+from .tracker_update_params import TrackerUpdateParams as TrackerUpdateParams
+from .agent_rpc_by_name_params import AgentRpcByNameParams as AgentRpcByNameParams
+from .task_message_content_param import TaskMessageContentParam as TaskMessageContentParam
+from .tool_request_content_param import ToolRequestContentParam as ToolRequestContentParam
+from .tool_response_content_param import ToolResponseContentParam as ToolResponseContentParam
+from .task_delete_by_name_response import TaskDeleteByNameResponse as TaskDeleteByNameResponse

agentex/types/acp_type.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["AcpType"]
+
+AcpType: TypeAlias = Literal["sync", "agentic"]

agentex/types/agent.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .acp_type import AcpType
+
+__all__ = ["Agent"]
+
+
+class Agent(BaseModel):
+    id: str
+    """The unique identifier of the agent."""
+
+    acp_type: AcpType
+    """The type of the ACP Server (Either sync or agentic)"""
+
+    description: str
+    """The description of the action."""
+
+    name: str
+    """The unique name of the agent."""
+
+    status: Optional[Literal["Pending", "Building", "Ready", "Failed", "Unknown"]] = None
+    """The status of the action, indicating if it's building, ready, failed, etc."""
+
+    status_reason: Optional[str] = None
+    """The reason for the status of the action."""

agentex/types/agent_list_params.py

@@ -0,0 +1,13 @@
+# 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__ = ["AgentListParams"]
+
+
+class AgentListParams(TypedDict, total=False):
+    task_id: Optional[str]
+    """Task ID"""

agentex/types/agent_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 .agent import Agent
+
+__all__ = ["AgentListResponse"]
+
+AgentListResponse: TypeAlias = List[Agent]

agentex/types/agent_rpc_by_name_params.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypedDict
+
+from .agent_rpc_params import AgentRpcParams
+
+__all__ = ["AgentRpcByNameParams"]
+
+
+class AgentRpcByNameParams(TypedDict, total=False):
+    method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]]
+
+    params: Required[AgentRpcParams]
+    """The parameters for the agent RPC request"""
+
+    id: Union[int, str, None]
+
+    jsonrpc: Literal["2.0"]

agentex/types/agent_rpc_params.py

@@ -0,0 +1,51 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Optional
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from .task_message_content_param import TaskMessageContentParam
+
+__all__ = ["AgentRpcParams", "CreateTaskRequest", "CancelTaskRequest", "SendMessageRequest", "SendEventRequest"]
+
+
+class CreateTaskRequest(TypedDict, total=False):
+    name: Optional[str]
+    """The name of the task to create"""
+
+    params: Optional[Dict[str, object]]
+    """The parameters for the task"""
+
+
+class CancelTaskRequest(TypedDict, total=False):
+    task_id: Optional[str]
+    """The ID of the task to cancel. Either this or task_name must be provided."""
+
+    task_name: Optional[str]
+    """The name of the task to cancel. Either this or task_id must be provided."""
+
+
+class SendMessageRequest(TypedDict, total=False):
+    content: Required[TaskMessageContentParam]
+    """The message that was sent to the agent"""
+
+    stream: bool
+    """Whether to stream the response message back to the client"""
+
+    task_id: Optional[str]
+    """The ID of the task that the message was sent to"""
+
+
+class SendEventRequest(TypedDict, total=False):
+    content: Optional[TaskMessageContentParam]
+    """The content to send to the event"""
+
+    task_id: Optional[str]
+    """The ID of the task that the event was sent to"""
+
+    task_name: Optional[str]
+    """The name of the task that the event was sent to"""
+
+
+AgentRpcParams: TypeAlias = Union[CreateTaskRequest, CancelTaskRequest, SendMessageRequest, SendEventRequest]

agentex/types/agent_rpc_params1.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypedDict
+
+from . import agent_rpc_params
+
+__all__ = ["AgentRpcParams"]
+
+
+class AgentRpcParams(TypedDict, total=False):
+    method: Required[Literal["event/send", "task/create", "message/send", "task/cancel"]]
+
+    params: Required[agent_rpc_params.AgentRpcParams]
+    """The parameters for the agent RPC request"""
+
+    id: Union[int, str, None]
+
+    jsonrpc: Literal["2.0"]

agentex/types/agent_rpc_response.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .agent_rpc_result import AgentRpcResult
+
+__all__ = ["AgentRpcResponse"]
+
+
+class AgentRpcResponse(BaseModel):
+    result: Optional[AgentRpcResult] = None
+    """The result of the agent RPC request"""
+
+    id: Union[int, str, None] = None
+
+    error: Optional[object] = None
+
+    jsonrpc: Optional[Literal["2.0"]] = None