agentex-sdk 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

agentex/_client.py

@@ -21,7 +21,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import spans, tasks, agents, events, states, tracker
+from .resources import spans, tasks, agents, events, states, tracker, deployment_history
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError
 from ._base_client import (
@@ -57,6 +57,7 @@ class Agentex(SyncAPIClient):
     states: states.StatesResource
     events: events.EventsResource
     tracker: tracker.TrackerResource
+    deployment_history: deployment_history.DeploymentHistoryResource
     with_raw_response: AgentexWithRawResponse
     with_streaming_response: AgentexWithStreamedResponse
 
@@ -141,6 +142,7 @@ class Agentex(SyncAPIClient):
         self.states = states.StatesResource(self)
         self.events = events.EventsResource(self)
         self.tracker = tracker.TrackerResource(self)
+        self.deployment_history = deployment_history.DeploymentHistoryResource(self)
         self.with_raw_response = AgentexWithRawResponse(self)
         self.with_streaming_response = AgentexWithStreamedResponse(self)
 
@@ -261,6 +263,7 @@ class AsyncAgentex(AsyncAPIClient):
     states: states.AsyncStatesResource
     events: events.AsyncEventsResource
     tracker: tracker.AsyncTrackerResource
+    deployment_history: deployment_history.AsyncDeploymentHistoryResource
     with_raw_response: AsyncAgentexWithRawResponse
     with_streaming_response: AsyncAgentexWithStreamedResponse
 
@@ -345,6 +348,7 @@ class AsyncAgentex(AsyncAPIClient):
         self.states = states.AsyncStatesResource(self)
         self.events = events.AsyncEventsResource(self)
         self.tracker = tracker.AsyncTrackerResource(self)
+        self.deployment_history = deployment_history.AsyncDeploymentHistoryResource(self)
         self.with_raw_response = AsyncAgentexWithRawResponse(self)
         self.with_streaming_response = AsyncAgentexWithStreamedResponse(self)
 
@@ -466,6 +470,7 @@ class AgentexWithRawResponse:
         self.states = states.StatesResourceWithRawResponse(client.states)
         self.events = events.EventsResourceWithRawResponse(client.events)
         self.tracker = tracker.TrackerResourceWithRawResponse(client.tracker)
+        self.deployment_history = deployment_history.DeploymentHistoryResourceWithRawResponse(client.deployment_history)
 
 
 class AsyncAgentexWithRawResponse:
@@ -477,6 +482,9 @@ class AsyncAgentexWithRawResponse:
         self.states = states.AsyncStatesResourceWithRawResponse(client.states)
         self.events = events.AsyncEventsResourceWithRawResponse(client.events)
         self.tracker = tracker.AsyncTrackerResourceWithRawResponse(client.tracker)
+        self.deployment_history = deployment_history.AsyncDeploymentHistoryResourceWithRawResponse(
+            client.deployment_history
+        )
 
 
 class AgentexWithStreamedResponse:
@@ -488,6 +496,9 @@ class AgentexWithStreamedResponse:
         self.states = states.StatesResourceWithStreamingResponse(client.states)
         self.events = events.EventsResourceWithStreamingResponse(client.events)
         self.tracker = tracker.TrackerResourceWithStreamingResponse(client.tracker)
+        self.deployment_history = deployment_history.DeploymentHistoryResourceWithStreamingResponse(
+            client.deployment_history
+        )
 
 
 class AsyncAgentexWithStreamedResponse:
@@ -499,6 +510,9 @@ class AsyncAgentexWithStreamedResponse:
         self.states = states.AsyncStatesResourceWithStreamingResponse(client.states)
         self.events = events.AsyncEventsResourceWithStreamingResponse(client.events)
         self.tracker = tracker.AsyncTrackerResourceWithStreamingResponse(client.tracker)
+        self.deployment_history = deployment_history.AsyncDeploymentHistoryResourceWithStreamingResponse(
+            client.deployment_history
+        )
 
 
 Client = Agentex

agentex/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "agentex"
-__version__ = "0.6.1"  # x-release-please-version
+__version__ = "0.6.3"  # x-release-please-version

agentex/lib/adk/providers/_modules/openai.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sys
 from typing import Any, Literal
 from datetime import timedelta
 
@@ -12,6 +13,12 @@ from temporalio.common import RetryPolicy
 from agents.agent_output import AgentOutputSchemaBase
 from agents.model_settings import ModelSettings
 
+# Use warnings.deprecated in Python 3.13+, typing_extensions.deprecated for older versions
+if sys.version_info >= (3, 13):
+    from warnings import deprecated
+else:
+    from typing_extensions import deprecated
+
 from agentex.lib.utils.logging import make_logger
 from agentex.lib.utils.temporal import in_temporal_workflow
 from agentex.lib.core.tracing.tracer import AsyncTracer
@@ -383,6 +390,10 @@ class OpenAIModule:
             previous_response_id=previous_response_id,
         )
 
+    @deprecated(
+        "Use the OpenAI Agents SDK integration with Temporal instead. "
+        "See examples in tutorials/10_async/10_temporal/ for migration guidance."
+    )
     async def run_agent_streamed_auto_send(
         self,
         task_id: str,
@@ -413,6 +424,10 @@ class OpenAIModule:
         """
         Run an agent with streaming enabled and automatic TaskMessage creation.
 
+        .. deprecated::
+            Use the OpenAI Agents SDK integration with Temporal instead.
+            See examples in tutorials/10_async/10_temporal/ for migration guidance.
+
         Args:
             task_id: The ID of the task to run the agent for.
             input_list: List of input data for the agent.
@@ -494,4 +509,4 @@ class OpenAIModule:
                 output_guardrails=output_guardrails,
                 max_turns=max_turns,
                 previous_response_id=previous_response_id,
-            )
+            )

agentex/lib/cli/commands/init.py

@@ -126,15 +126,15 @@ def init():
     table.add_column("Description", style="white")
     table.add_row(
         "[bold cyan]Async - ACP Only[/bold cyan]",
-        "A simple synchronous agent that handles tasks directly. Best for straightforward agents that don't need long-running operations.",
+        "Asynchronous, non-blocking agent that can process multiple concurrent requests. Best for straightforward asynchronous agents that don't need durable execution. Good for asynchronous workflows, stateful applications, and multi-step analysis.",
     )
     table.add_row(
         "[bold cyan]Async - Temporal[/bold cyan]",
-        "An asynchronous agent powered by Temporal workflows. Best for agents that need to handle long-running tasks, retries, or complex state management.",
+        "Asynchronous, non-blocking agent with durable execution for all steps. Best for production-grade agents that require complex multi-step tool calls, human-in-the-loop approvals, and long-running processes that require transactional reliability.",
     )
     table.add_row(
         "[bold cyan]Sync ACP[/bold cyan]",
-        "A synchronous agent that handles tasks directly. The difference is that this Sync ACP will be required to respond with the results in the same call as the input.Best for straightforward agents that don't need long-running operations.",
+        "Synchronous agent that processes one request per task with a simple request-response pattern. Best for low-latency use cases, FAQ bots, translation services, and data lookups.",
     )
     console.print()
     console.print(table)

agentex/lib/core/temporal/plugins/openai_agents/hooks/hooks.py

@@ -55,9 +55,8 @@ class TemporalStreamingHooks(RunHooks):
     Power users can ignore this class and subclass agents.RunHooks directly for full control.
 
     Note:
-        Tool arguments are not available in hooks due to OpenAI SDK architecture.
-        The SDK's hook signature doesn't include tool arguments - they're only passed
-        to the actual tool function. This is why arguments={} in ToolRequestContent.
+        Tool arguments are extracted from the ToolContext's tool_arguments field,
+        which contains a JSON string of the arguments passed to the tool.
 
     Attributes:
         task_id: The AgentEx task ID for routing streamed events
@@ -108,21 +107,30 @@ class TemporalStreamingHooks(RunHooks):
     async def on_tool_start(self, context: RunContextWrapper, agent: Agent, tool: Tool) -> None:  # noqa: ARG002
         """Stream tool request when a tool starts execution.
 
-        Extracts the tool_call_id from the context and streams a ToolRequestContent
-        message to the UI showing that the tool is about to execute.
-
-        Note: Tool arguments are not available in the hook context due to OpenAI SDK
-        design. The hook signature doesn't include tool arguments - they're passed
-        directly to the tool function instead. We send an empty dict as a placeholder.
+        Extracts the tool_call_id and tool_arguments from the context and streams a
+        ToolRequestContent message to the UI showing that the tool is about to execute.
 
         Args:
-            context: The run context wrapper (will be a ToolContext with tool_call_id)
+            context: The run context wrapper (will be a ToolContext with tool_call_id and tool_arguments)
             agent: The agent executing the tool
             tool: The tool being executed
         """
+        import json
+
         tool_context = context if isinstance(context, ToolContext) else None
         tool_call_id = tool_context.tool_call_id if tool_context else f"call_{id(tool)}"
 
+        # Extract tool arguments from context
+        tool_arguments = {}
+        if tool_context and hasattr(tool_context, 'tool_arguments'):
+            try:
+                # tool_arguments is a JSON string, parse it
+                tool_arguments = json.loads(tool_context.tool_arguments)
+            except (json.JSONDecodeError, TypeError):
+                # If parsing fails, log and use empty dict
+                logger.warning(f"Failed to parse tool arguments: {tool_context.tool_arguments}")
+                tool_arguments = {}
+
         await workflow.execute_activity_method(
             stream_lifecycle_content,
             args=[
@@ -131,7 +139,7 @@ class TemporalStreamingHooks(RunHooks):
                     author="agent",
                     tool_call_id=tool_call_id,
                     name=tool.name,
-                    arguments={},  # Not available in hook context - SDK limitation
+                    arguments=tool_arguments,  # Now properly extracted from context
                 ),
             ],
             start_to_close_timeout=self.timeout,

agentex/lib/core/temporal/plugins/openai_agents/models/temporal_streaming_model.py

@@ -62,13 +62,62 @@ from agentex.lib.core.temporal.plugins.openai_agents.interceptors.context_interc
 # Create logger for this module
 logger = logging.getLogger("agentex.temporal.streaming")
 
+
+def _serialize_item(item: Any) -> dict[str, Any]:
+    """
+    Universal serializer for any item type from OpenAI Agents SDK.
+
+    Uses model_dump() for Pydantic models, otherwise extracts attributes manually.
+    Filters out internal Pydantic fields that can't be serialized.
+    """
+    if hasattr(item, 'model_dump'):
+        # Pydantic model - use model_dump for proper serialization
+        try:
+            return item.model_dump(mode='json', exclude_unset=True)
+        except Exception:
+            # Fallback to dict conversion
+            return dict(item) if hasattr(item, '__iter__') else {}
+    else:
+        # Not a Pydantic model - extract attributes manually
+        item_dict = {}
+        for attr_name in dir(item):
+            if not attr_name.startswith('_') and attr_name not in ('model_fields', 'model_config', 'model_computed_fields'):
+                try:
+                    attr_value = getattr(item, attr_name, None)
+                    # Skip methods and None values
+                    if attr_value is not None and not callable(attr_value):
+                        # Convert to JSON-serializable format
+                        if hasattr(attr_value, 'model_dump'):
+                            item_dict[attr_name] = attr_value.model_dump()
+                        elif isinstance(attr_value, (str, int, float, bool, list, dict)):
+                            item_dict[attr_name] = attr_value
+                        else:
+                            item_dict[attr_name] = str(attr_value)
+                except Exception:
+                    # Skip attributes that can't be accessed
+                    pass
+        return item_dict
+
+
 class TemporalStreamingModel(Model):
     """Custom model implementation with streaming support."""
 
-    def __init__(self, model_name: str = "gpt-4o", _use_responses_api: bool = True):
-        """Initialize the streaming model with OpenAI client and model name."""
-        # Match the default behavior with no retries (Temporal handles retries)
-        self.client = AsyncOpenAI(max_retries=0)
+    def __init__(
+        self,
+        model_name: str = "gpt-4o",
+        _use_responses_api: bool = True,
+        openai_client: Optional[AsyncOpenAI] = None,
+    ):
+        """Initialize the streaming model with OpenAI client and model name.
+
+        Args:
+            model_name: The name of the OpenAI model to use (default: "gpt-4o")
+            _use_responses_api: Internal flag for responses API (deprecated, always True)
+            openai_client: Optional custom AsyncOpenAI client. If not provided, a default
+                          client with max_retries=0 will be created (since Temporal handles retries)
+        """
+        # Use provided client or create default (Temporal handles retries)
+        self.client = openai_client if openai_client is not None else AsyncOpenAI(max_retries=0)
         self.model_name = model_name
         # Always use Responses API for all models
         self.use_responses_api = True
@@ -77,7 +126,7 @@ class TemporalStreamingModel(Model):
         agentex_client = create_async_agentex_client()
         self.tracer = AsyncTracer(agentex_client)
 
-        logger.info(f"[TemporalStreamingModel] Initialized model={self.model_name}, use_responses_api={self.use_responses_api}, tracer=initialized")
+        logger.info(f"[TemporalStreamingModel] Initialized model={self.model_name}, use_responses_api={self.use_responses_api}, custom_client={openai_client is not None}, tracer=initialized")
 
     def _non_null_or_not_given(self, value: Any) -> Any:
         """Convert None to NOT_GIVEN sentinel, matching OpenAI SDK pattern."""
@@ -739,6 +788,35 @@ class TemporalStreamingModel(Model):
                     output_tokens_details=OutputTokensDetails(reasoning_tokens=len(''.join(reasoning_contents)) // 4),  # Approximate
                 )
 
+                # Serialize response output items for span tracing
+                new_items = []
+                final_output = None
+
+                for item in response_output:
+                    try:
+                        item_dict = _serialize_item(item)
+                        if item_dict:
+                            new_items.append(item_dict)
+
+                            # Extract final_output from message type if available
+                            if item_dict.get('type') == 'message' and not final_output:
+                                content = item_dict.get('content', [])
+                                if content and isinstance(content, list):
+                                    for content_part in content:
+                                        if isinstance(content_part, dict) and 'text' in content_part:
+                                            final_output = content_part['text']
+                                            break
+                    except Exception as e:
+                        logger.warning(f"Failed to serialize item in temporal_streaming_model: {e}")
+                        continue
+
+                # Set span output with structured data
+                if span:
+                    span.output = {
+                        "new_items": new_items,
+                        "final_output": final_output,
+                    }
+
                 # Return the response
                 return ModelResponse(
                     output=response_output,

agentex/lib/core/temporal/plugins/openai_agents/models/temporal_tracing_model.py

@@ -7,9 +7,10 @@ context interceptor to access task_id, trace_id, and parent_span_id.
 The key innovation is that these are thin wrappers around the standard OpenAI models,
 avoiding code duplication while adding tracing capabilities.
 """
+from __future__ import annotations
 
 import logging
-from typing import List, Union, Optional, override
+from typing import Any, List, Union, Optional, override
 
 from agents import (
     Tool,
@@ -22,6 +23,7 @@ from agents import (
     TResponseInputItem,
     AgentOutputSchemaBase,
 )
+from openai import AsyncOpenAI
 from openai.types.responses import ResponsePromptParam
 from agents.models.openai_responses import OpenAIResponsesModel
 from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
@@ -41,6 +43,42 @@ from agentex.lib.core.temporal.plugins.openai_agents.interceptors.context_interc
 logger = logging.getLogger("agentex.temporal.tracing")
 
 
+def _serialize_item(item: Any) -> dict[str, Any]:
+    """
+    Universal serializer for any item type from OpenAI Agents SDK.
+
+    Uses model_dump() for Pydantic models, otherwise extracts attributes manually.
+    Filters out internal Pydantic fields that can't be serialized.
+    """
+    if hasattr(item, 'model_dump'):
+        # Pydantic model - use model_dump for proper serialization
+        try:
+            return item.model_dump(mode='json', exclude_unset=True)
+        except Exception:
+            # Fallback to dict conversion
+            return dict(item) if hasattr(item, '__iter__') else {}
+    else:
+        # Not a Pydantic model - extract attributes manually
+        item_dict = {}
+        for attr_name in dir(item):
+            if not attr_name.startswith('_') and attr_name not in ('model_fields', 'model_config', 'model_computed_fields'):
+                try:
+                    attr_value = getattr(item, attr_name, None)
+                    # Skip methods and None values
+                    if attr_value is not None and not callable(attr_value):
+                        # Convert to JSON-serializable format
+                        if hasattr(attr_value, 'model_dump'):
+                            item_dict[attr_name] = attr_value.model_dump()
+                        elif isinstance(attr_value, (str, int, float, bool, list, dict)):
+                            item_dict[attr_name] = attr_value
+                        else:
+                            item_dict[attr_name] = str(attr_value)
+                except Exception:
+                    # Skip attributes that can't be accessed
+                    pass
+        return item_dict
+
+
 class TemporalTracingModelProvider(OpenAIProvider):
     """Model provider that returns OpenAI models wrapped with AgentEx tracing.
 
@@ -49,17 +87,25 @@ class TemporalTracingModelProvider(OpenAIProvider):
     the context interceptor enabled.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, openai_client: Optional[AsyncOpenAI] = None, **kwargs):
         """Initialize the tracing model provider.
 
-        Accepts all the same arguments as OpenAIProvider.
+        Args:
+            openai_client: Optional custom AsyncOpenAI client. If provided, this client
+                          will be used for all model calls. If not provided, OpenAIProvider
+                          will create a default client.
+            **kwargs: All other arguments are passed to OpenAIProvider.
         """
-        super().__init__(*args, **kwargs)
+        # Pass openai_client to parent if provided
+        if openai_client is not None:
+            super().__init__(openai_client=openai_client, **kwargs)
+        else:
+            super().__init__(**kwargs)
 
         # Initialize tracer for all models
         agentex_client = create_async_agentex_client()
         self._tracer = AsyncTracer(agentex_client)
-        logger.info("[TemporalTracingModelProvider] Initialized with AgentEx tracer")
+        logger.info(f"[TemporalTracingModelProvider] Initialized with AgentEx tracer, custom_client={openai_client is not None}")
 
     @override
     def get_model(self, model_name: Optional[str]) -> Model:
@@ -171,15 +217,35 @@ class TemporalTracingResponsesModel(Model):
                         **kwargs,
                     )
 
-                    # Add response info to span output
+                    # Serialize response output items for span tracing
+                    new_items = []
+                    final_output = None
+
+                    if hasattr(response, 'output') and response.output:
+                        response_output = response.output if isinstance(response.output, list) else [response.output]
+
+                        for item in response_output:
+                            try:
+                                item_dict = _serialize_item(item)
+                                if item_dict:
+                                    new_items.append(item_dict)
+
+                                    # Extract final_output from message type if available
+                                    if item_dict.get('type') == 'message' and not final_output:
+                                        content = item_dict.get('content', [])
+                                        if content and isinstance(content, list):
+                                            for content_part in content:
+                                                if isinstance(content_part, dict) and 'text' in content_part:
+                                                    final_output = content_part['text']
+                                                    break
+                            except Exception as e:
+                                logger.warning(f"Failed to serialize item in temporal tracing model: {e}")
+                                continue
+
+                    # Set span output with structured data
                     span.output = {  # type: ignore[attr-defined]
-                        "response_id": getattr(response, "id", None),
-                        "model_used": getattr(response, "model", None),
-                        "usage": {
-                            "input_tokens": response.usage.input_tokens if response.usage else None,
-                            "output_tokens": response.usage.output_tokens if response.usage else None,
-                            "total_tokens": response.usage.total_tokens if response.usage else None,
-                        } if response.usage else None,
+                        "new_items": new_items,
+                        "final_output": final_output,
                     }
 
                     return response
@@ -284,15 +350,35 @@ class TemporalTracingChatCompletionsModel(Model):
                         **kwargs,
                     )
 
-                    # Add response info to span output
+                    # Serialize response output items for span tracing
+                    new_items = []
+                    final_output = None
+
+                    if hasattr(response, 'output') and response.output:
+                        response_output = response.output if isinstance(response.output, list) else [response.output]
+
+                        for item in response_output:
+                            try:
+                                item_dict = _serialize_item(item)
+                                if item_dict:
+                                    new_items.append(item_dict)
+
+                                    # Extract final_output from message type if available
+                                    if item_dict.get('type') == 'message' and not final_output:
+                                        content = item_dict.get('content', [])
+                                        if content and isinstance(content, list):
+                                            for content_part in content:
+                                                if isinstance(content_part, dict) and 'text' in content_part:
+                                                    final_output = content_part['text']
+                                                    break
+                            except Exception as e:
+                                logger.warning(f"Failed to serialize item in temporal tracing model: {e}")
+                                continue
+
+                    # Set span output with structured data
                     span.output = {  # type: ignore[attr-defined]
-                        "response_id": getattr(response, "id", None),
-                        "model_used": getattr(response, "model", None),
-                        "usage": {
-                            "input_tokens": response.usage.input_tokens if response.usage else None,
-                            "output_tokens": response.usage.output_tokens if response.usage else None,
-                            "total_tokens": response.usage.total_tokens if response.usage else None,
-                        } if response.usage else None,
+                        "new_items": new_items,
+                        "final_output": final_output,
                     }
 
                     return response

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/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.1.dist-info → agentex_sdk-0.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentex-sdk
-Version: 0.6.1
+Version: 0.6.3
 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.dist-info → agentex_sdk-0.6.3.dist-info}/RECORD

@@ -1,6 +1,6 @@
 agentex/__init__.py,sha256=TvS8DtvGAnubcoUjYIsuCpBzpsdpxBaJCS76s-l-PRo,2712
 agentex/_base_client.py,sha256=g9DKGvDYgnfB-j2mI6ZigM-mIIwQIlTrsLl4wMgkpyI,67048
-agentex/_client.py,sha256=xNwZptOIt3bTyDgyN4lGoSHIJ3lpzD_eBzhAtl074zs,20478
+agentex/_client.py,sha256=7F6gjeSIunCDoqfsJoLYpfIsGzv95Q-Y1ewI0-fp96k,21388
 agentex/_compat.py,sha256=DQBVORjFb33zch24jzkhM14msvnzY7mmSmgDLaVFUM8,6562
 agentex/_constants.py,sha256=oGldMuFz7eZtwD8_6rJUippKhZB5fGSA7ffbCDGourA,466
 agentex/_exceptions.py,sha256=B09aFjWFRSShb9BFJd-MNDblsGDyGk3w-vItYmjg_AI,3222
@@ -11,7 +11,7 @@ agentex/_resource.py,sha256=S1t7wmR5WUvoDIhZjo_x-E7uoTJBynJ3d8tPJMQYdjw,1106
 agentex/_response.py,sha256=Tb9zazsnemO2rTxWtBjAD5WBqlhli5ZaXGbiKgdu5DE,28794
 agentex/_streaming.py,sha256=p-m2didLkbw_VBZsP4QqeIPc2haAdGZmB0BOU3gUM2A,10153
 agentex/_types.py,sha256=F6X63N7bOstytAtVqJ9Yl7T_JbR9Od2MJfZ_iK5DqOY,7237
-agentex/_version.py,sha256=Y_IaDKNMRMt_wEqfF8n1vFCUGPlmnTYN9PQTWnI2XSY,159
+agentex/_version.py,sha256=c2fQYF_Uula9lejrW5sHf4Mfcdn6IMrnCDZlp3EDgno,159
 agentex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentex/_utils/__init__.py,sha256=7fch0GT9zpNnErbciSpUNa-SjTxxjY6kxHxKMOM4AGs,2305
 agentex/_utils/_compat.py,sha256=D8gtAvjJQrDWt9upS0XaG9Rr5l1QhiAx_I_1utT_tt0,1195
@@ -43,7 +43,7 @@ agentex/lib/adk/_modules/tracing.py,sha256=LZvItZg2ALZZMvJasrsGEBgss4wnXGMnL_lw0
 agentex/lib/adk/providers/__init__.py,sha256=bOS-D_lXV3QXRtGKrUvsYb2ZAcZG51ZAtHdfiHgYN-M,306
 agentex/lib/adk/providers/_modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentex/lib/adk/providers/_modules/litellm.py,sha256=6eOdEpd1g9ZljQHXtIokjGymlFpnaw2g8ow11hldovo,9470
-agentex/lib/adk/providers/_modules/openai.py,sha256=Nm8YGRiCjmOI06sxzmqDrearFUNFXeoeM4pBLg4QMSc,23099
+agentex/lib/adk/providers/_modules/openai.py,sha256=rguTE4uGLodqr8zx5GRRtSkcWC9llNA1kUFKF0yhdK0,23679
 agentex/lib/adk/providers/_modules/sgp.py,sha256=x64axb0oVmVh5W8hwpnMMPqxad2HySf2DYHPxRNwjck,3208
 agentex/lib/adk/providers/_modules/sync_provider.py,sha256=9RQ_gMICiUN97bvnbVnVypiKoalCeiUiqonn3nKAjwU,26324
 agentex/lib/adk/utils/__init__.py,sha256=7f6ayV0_fqyw5cwzVANNcZWGJZ-vrrYtZ0qi7KKBRFs,130
@@ -53,7 +53,7 @@ agentex/lib/adk/utils/_modules/templating.py,sha256=tSiJGoDrF-XkMEi4MB_wVH6nyKyh
 agentex/lib/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentex/lib/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentex/lib/cli/commands/agents.py,sha256=E6O7p3B3P4yX-oYWRtzfbEyI5Pws-yzFi-htYJ7B_kY,14079
-agentex/lib/cli/commands/init.py,sha256=9JnHE62dcjQjrza5JSeRwq5UeW7O3p68DiMhq8lP-jc,14690
+agentex/lib/cli/commands/init.py,sha256=u2FaPXJD-cJ2dYgdkqDCQezXJXV9-mPtp9_ygOGOsNA,14841
 agentex/lib/cli/commands/main.py,sha256=QWychw-Xq3nQ00BMypgOEF4w1WauNrgQ06PDardNP_8,1042
 agentex/lib/cli/commands/secrets.py,sha256=t4zvoyjOHmw-8qp6nsxdZCvqy43QXOl0MWXA3ooBO6Q,5640
 agentex/lib/cli/commands/tasks.py,sha256=fvZJjYI8Dh-6nbTVpRa2-VdF6A8D4w3Dmd4tMslSTPI,3741
@@ -167,12 +167,12 @@ agentex/lib/core/temporal/plugins/openai_agents/README.md,sha256=FzvW3xM7dCvdxq2
 agentex/lib/core/temporal/plugins/openai_agents/__init__.py,sha256=ZLHVA3LAkPDvRQlSLnJlPs0sDzqy6sUtwlapoG02Hyw,3174
 agentex/lib/core/temporal/plugins/openai_agents/hooks/__init__.py,sha256=soOuozGd7H9uWSwwjA60psUGtRR4xQ6e4wfoQbr73Fo,483
 agentex/lib/core/temporal/plugins/openai_agents/hooks/activities.py,sha256=APpAOZQ90kbhaNpJ6pAeZ2mxxcPx37AchCuLJzeGzB0,3088
-agentex/lib/core/temporal/plugins/openai_agents/hooks/hooks.py,sha256=iATUCspNLweCGuG8WGd29wK8_SiZPlor5P3G9p5nvH0,7853
+agentex/lib/core/temporal/plugins/openai_agents/hooks/hooks.py,sha256=qbB6RLPlveEIIfziXZBRMkaPJQMQBPsovIX_yM4QuWU,8100
 agentex/lib/core/temporal/plugins/openai_agents/interceptors/__init__.py,sha256=hrj6lRPi9nb_HAohRK4oPnaji69QQ6brj-Wu2q0mU0s,521
 agentex/lib/core/temporal/plugins/openai_agents/interceptors/context_interceptor.py,sha256=sBLJonJJ5Ke1BJIlzbqtGeO5p8NIbvftbEYQbjgeZCE,7256
 agentex/lib/core/temporal/plugins/openai_agents/models/__init__.py,sha256=FeTt91JkSfYLlCTdrVFpjcQ0asbQyCd6Rl5efqZkslo,791
-agentex/lib/core/temporal/plugins/openai_agents/models/temporal_streaming_model.py,sha256=cL0-b1ojZsGZhsJHku8k6bZqRntWJUerHMHNH4MLf94,38700
-agentex/lib/core/temporal/plugins/openai_agents/models/temporal_tracing_model.py,sha256=hvnOkGttkGG63lwe2lt_mXmDEdDw-ZSliVOncvA79T8,13116
+agentex/lib/core/temporal/plugins/openai_agents/models/temporal_streaming_model.py,sha256=ZODPIUuvSZO5eYhByMv2n87SOKYjAh9JunkJm8ECRPQ,42310
+agentex/lib/core/temporal/plugins/openai_agents/models/temporal_tracing_model.py,sha256=BiuIhSvyNfocwMYQtxOoqgMpyJsMHLkyXzYPYnw4ChA,17458
 agentex/lib/core/temporal/plugins/openai_agents/tests/__init__.py,sha256=suEVJuonfBoVZ3IqdO0UMn0hkFFzDqRoso0VEOit-KQ,80
 agentex/lib/core/temporal/plugins/openai_agents/tests/conftest.py,sha256=oMI_3dVn6DoiLgCjRVUeQE_Z2Gz3tGTwPxTQ1krjKSE,7692
 agentex/lib/core/temporal/plugins/openai_agents/tests/test_streaming_model.py,sha256=w8rkQbn3j_f9GZSXHl5j8FMDPaBQ3wED-BFzxQaeBIc,32909
@@ -248,8 +248,9 @@ agentex/lib/utils/registration.py,sha256=eMumlbRgf6Bo8I2Q2D3qX1x8vII3FiliDxYnDj9
 agentex/lib/utils/temporal.py,sha256=sXo8OPMMXiyrF7OSBCJBuN_ufyQOD2bLOXgDbVZoyds,292
 agentex/lib/utils/dev_tools/__init__.py,sha256=oaHxw6ymfhNql-kzXHv3NWVHuqD4fHumasNXJG7kHTU,261
 agentex/lib/utils/dev_tools/async_messages.py,sha256=X1L60LyCSCdhtBw5Sn8ELoMadA1xuEPo_VxyemM9tm0,20083
-agentex/resources/__init__.py,sha256=74rMqWBzQ2dSrKQqsrd7-jskPws0O_ogkFltvZO3HoU,3265
+agentex/resources/__init__.py,sha256=RJUjEci2NLCmT00h5MbsMx1x_P5v9VQabKaconwza1c,3859
 agentex/resources/agents.py,sha256=ABj4CXuL3K5A-A12qUlkzrRTCKPL-tF-WLwsTYwNC88,47794
+agentex/resources/deployment_history.py,sha256=uRVhjVyu_UWyJgJ2EGOQbC1pdn-RleposC4ZbpvNF6c,10527
 agentex/resources/events.py,sha256=jbaP-a8nouqOHGVWhLvUEtHN5Um8-oaiB4W1VrkSX-0,10412
 agentex/resources/spans.py,sha256=805_ZnBhphdBiO8c2939xVUT4k5gZiZutfH5xBQx8OQ,21246
 agentex/resources/states.py,sha256=kT1M8GNu6UiHXl-o8kPzPdLhqpPfPtKVNMrTpkOvcQM,19714
@@ -258,7 +259,7 @@ agentex/resources/tracker.py,sha256=gdYdbKpFSwttLpkme5E9PnMU1ITxmQOGepYbXYNNWAM,
 agentex/resources/messages/__init__.py,sha256=_J1eusFtr_k6zrAntJSuqx6LWEUBSTrV1OZZh7MaDPE,1015
 agentex/resources/messages/batch.py,sha256=bYDIf0ZF3-sTKnGfFmzFQUn8LMtMYoniY977J3zr8q8,9653
 agentex/resources/messages/messages.py,sha256=JhdPPGyoBE4UzVx8hugkMJItx_wCNdShpzHCg8B6O68,18076
-agentex/types/__init__.py,sha256=cYokWfFJAL_UbS3EWhVc_WsUwOTEdw-XBL3_fBddJQU,4236
+agentex/types/__init__.py,sha256=JEDsom9CZpig5AWGV5UH_JRQ7ewW7_q1DUP6TQnnioI,4519
 agentex/types/acp_type.py,sha256=lEn_w4z-RIgyUVTQr8mm5l9OdFDQMDclbJU_lKa4Mi8,217
 agentex/types/agent.py,sha256=hwgmtylJYezzmGJbzbBQ7sn3oV2_bCZqgqlNq9WpZ0g,1318
 agentex/types/agent_list_params.py,sha256=7dGaeOTuGNzwliqAoxk1g1Z0LRD8XEWKYPvnBOLbsSY,392
@@ -271,6 +272,9 @@ agentex/types/agent_task_tracker.py,sha256=JK1kmQ7LIx1eWC-XaU2pJcIvdtQCmEn21dsJT
 agentex/types/data_content.py,sha256=EaGplLRZgCgaHnt-3KEAj1yFiAlOFODprpA8I1oiF3s,776
 agentex/types/data_content_param.py,sha256=5NtD2mcP1VfQJHcUCxgarzd4bwa07Ym2UIYqFWfAcbo,824
 agentex/types/data_delta.py,sha256=q3doAofriE7bQT3R-LbC8VYepytCoUOgHwJ6kWcJjr4,322
+agentex/types/deployment_history.py,sha256=SZiIB9tfUdqIuEgPN6WVlQ8oK64RtbC6TeUHewpQB50,767
+agentex/types/deployment_history_list_params.py,sha256=95H7arVPTPH720CUmmMqmkV0jzvS-8ab3ocnnnef47Q,392
+agentex/types/deployment_history_list_response.py,sha256=Hjw8WGYd4Qgv8tz7Fo6sA-gvNP3aBn0Axtj3h0U_ln8,315
 agentex/types/event.py,sha256=ilYXj7HlPDrgtQnh4YsgQrTXN-BxE7sOgi2ZorKYHdc,700
 agentex/types/event_list_params.py,sha256=Rrz0yo2w3gMTNYe3HQS9YCX1VktE_aaktuHezxoyMbA,594
 agentex/types/event_list_response.py,sha256=rjUCkwS0pXnfqHEVPEKZdLIGJ14uXOrjatuOfR36s5s,254
@@ -326,8 +330,8 @@ agentex/types/messages/batch_update_params.py,sha256=Ug5CThbD49a8j4qucg04OdmVrp_
 agentex/types/messages/batch_update_response.py,sha256=TbSBe6SuPzjXXWSj-nRjT1JHGBooTshHQQDa1AixQA8,278
 agentex/types/shared/__init__.py,sha256=IKs-Qn5Yja0kFh1G1kDqYZo43qrOu1hSoxlPdN-85dI,149
 agentex/types/shared/delete_response.py,sha256=8qH3zvQXaOHYQSHyXi7UQxdR4miTzR7V9K4zXVsiUyk,215
-agentex_sdk-0.6.1.dist-info/METADATA,sha256=Q28v5Aw3bhIIGpZqIxlLdA8rFn07-xbv0icU_w8kn8M,15375
-agentex_sdk-0.6.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-agentex_sdk-0.6.1.dist-info/entry_points.txt,sha256=V7vJuMZdF0UlvgX6KiBN7XUvq_cxF5kplcYvc1QlFaQ,62
-agentex_sdk-0.6.1.dist-info/licenses/LICENSE,sha256=Q1AOx2FtRcMlyMgQJ9eVN2WKPq2mQ33lnB4tvWxabLA,11337
-agentex_sdk-0.6.1.dist-info/RECORD,,
+agentex_sdk-0.6.3.dist-info/METADATA,sha256=FPfO3b3DUDmtZvVDGhsammLJgD_PlhwLG-zQqo7DzKI,15375
+agentex_sdk-0.6.3.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+agentex_sdk-0.6.3.dist-info/entry_points.txt,sha256=V7vJuMZdF0UlvgX6KiBN7XUvq_cxF5kplcYvc1QlFaQ,62
+agentex_sdk-0.6.3.dist-info/licenses/LICENSE,sha256=Q1AOx2FtRcMlyMgQJ9eVN2WKPq2mQ33lnB4tvWxabLA,11337
+agentex_sdk-0.6.3.dist-info/RECORD,,