letta-client 1.0.0a6__py3-none-any.whl → 1.0.0a8__py3-none-any.whl

letta_sdk/resources/telemetry.py → letta_client/resources/steps/trace.py

@@ -2,47 +2,45 @@
 
 from __future__ import annotations
 
-import typing_extensions
 from typing import Optional
 
 import httpx
 
-from .._types import Body, Query, Headers, NotGiven, not_given
-from .._compat import cached_property
-from .._resource import SyncAPIResource, AsyncAPIResource
-from .._response import (
+from ..._types import Body, Query, Headers, NotGiven, not_given
+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.provider_trace import ProviderTrace
+from ..._base_client import make_request_options
+from ...types.provider_trace import ProviderTrace
 
-__all__ = ["TelemetryResource", "AsyncTelemetryResource"]
+__all__ = ["TraceResource", "AsyncTraceResource"]
 
 
-class TelemetryResource(SyncAPIResource):
+class TraceResource(SyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> TelemetryResourceWithRawResponse:
+    def with_raw_response(self) -> TraceResourceWithRawResponse:
         """
         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/letta-ai/letta-python#accessing-raw-response-data-eg-headers
         """
-        return TelemetryResourceWithRawResponse(self)
+        return TraceResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> TelemetryResourceWithStreamingResponse:
+    def with_streaming_response(self) -> TraceResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/letta-ai/letta-python#with_streaming_response
         """
-        return TelemetryResourceWithStreamingResponse(self)
+        return TraceResourceWithStreamingResponse(self)
 
-    @typing_extensions.deprecated("deprecated")
     def retrieve(
         self,
         step_id: str,
@@ -55,11 +53,11 @@ class TelemetryResource(SyncAPIResource):
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Optional[ProviderTrace]:
         """
-        **DEPRECATED**: Use `GET /steps/{step_id}/trace` instead.
-
-        Retrieve provider trace by step ID.
+        Retrieve Trace For Step
 
         Args:
+          step_id: The ID of the step in the format 'step-<uuid4>'
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -71,7 +69,7 @@ class TelemetryResource(SyncAPIResource):
         if not step_id:
             raise ValueError(f"Expected a non-empty value for `step_id` but received {step_id!r}")
         return self._get(
-            f"/v1/telemetry/{step_id}",
+            f"/v1/steps/{step_id}/trace",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -79,27 +77,26 @@ class TelemetryResource(SyncAPIResource):
         )
 
 
-class AsyncTelemetryResource(AsyncAPIResource):
+class AsyncTraceResource(AsyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> AsyncTelemetryResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncTraceResourceWithRawResponse:
         """
         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/letta-ai/letta-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncTelemetryResourceWithRawResponse(self)
+        return AsyncTraceResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncTelemetryResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncTraceResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/letta-ai/letta-python#with_streaming_response
         """
-        return AsyncTelemetryResourceWithStreamingResponse(self)
+        return AsyncTraceResourceWithStreamingResponse(self)
 
-    @typing_extensions.deprecated("deprecated")
     async def retrieve(
         self,
         step_id: str,
@@ -112,11 +109,11 @@ class AsyncTelemetryResource(AsyncAPIResource):
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Optional[ProviderTrace]:
         """
-        **DEPRECATED**: Use `GET /steps/{step_id}/trace` instead.
-
-        Retrieve provider trace by step ID.
+        Retrieve Trace For Step
 
         Args:
+          step_id: The ID of the step in the format 'step-<uuid4>'
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -128,7 +125,7 @@ class AsyncTelemetryResource(AsyncAPIResource):
         if not step_id:
             raise ValueError(f"Expected a non-empty value for `step_id` but received {step_id!r}")
         return await self._get(
-            f"/v1/telemetry/{step_id}",
+            f"/v1/steps/{step_id}/trace",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -136,45 +133,37 @@ class AsyncTelemetryResource(AsyncAPIResource):
         )
 
 
-class TelemetryResourceWithRawResponse:
-    def __init__(self, telemetry: TelemetryResource) -> None:
-        self._telemetry = telemetry
+class TraceResourceWithRawResponse:
+    def __init__(self, trace: TraceResource) -> None:
+        self._trace = trace
 
-        self.retrieve = (  # pyright: ignore[reportDeprecated]
-            to_raw_response_wrapper(
-                telemetry.retrieve,  # pyright: ignore[reportDeprecated],
-            )
+        self.retrieve = to_raw_response_wrapper(
+            trace.retrieve,
         )
 
 
-class AsyncTelemetryResourceWithRawResponse:
-    def __init__(self, telemetry: AsyncTelemetryResource) -> None:
-        self._telemetry = telemetry
+class AsyncTraceResourceWithRawResponse:
+    def __init__(self, trace: AsyncTraceResource) -> None:
+        self._trace = trace
 
-        self.retrieve = (  # pyright: ignore[reportDeprecated]
-            async_to_raw_response_wrapper(
-                telemetry.retrieve,  # pyright: ignore[reportDeprecated],
-            )
+        self.retrieve = async_to_raw_response_wrapper(
+            trace.retrieve,
         )
 
 
-class TelemetryResourceWithStreamingResponse:
-    def __init__(self, telemetry: TelemetryResource) -> None:
-        self._telemetry = telemetry
+class TraceResourceWithStreamingResponse:
+    def __init__(self, trace: TraceResource) -> None:
+        self._trace = trace
 
-        self.retrieve = (  # pyright: ignore[reportDeprecated]
-            to_streamed_response_wrapper(
-                telemetry.retrieve,  # pyright: ignore[reportDeprecated],
-            )
+        self.retrieve = to_streamed_response_wrapper(
+            trace.retrieve,
         )
 
 
-class AsyncTelemetryResourceWithStreamingResponse:
-    def __init__(self, telemetry: AsyncTelemetryResource) -> None:
-        self._telemetry = telemetry
+class AsyncTraceResourceWithStreamingResponse:
+    def __init__(self, trace: AsyncTraceResource) -> None:
+        self._trace = trace
 
-        self.retrieve = (  # pyright: ignore[reportDeprecated]
-            async_to_streamed_response_wrapper(
-                telemetry.retrieve,  # pyright: ignore[reportDeprecated],
-            )
+        self.retrieve = async_to_streamed_response_wrapper(
+            trace.retrieve,
         )

{letta_sdk → letta_client}/resources/tags.py

@@ -9,7 +9,7 @@ import httpx
 
 from ..types import tag_list_params
 from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
-from .._utils import maybe_transform, async_maybe_transform
+from .._utils import maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -18,7 +18,8 @@ from .._response import (
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from .._base_client import make_request_options
+from ..pagination import SyncArrayPage, AsyncArrayPage
+from .._base_client import AsyncPaginator, make_request_options
 from ..types.tag_list_response import TagListResponse
 
 __all__ = ["TagsResource", "AsyncTagsResource"]
@@ -60,7 +61,7 @@ class TagsResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> TagListResponse:
+    ) -> SyncArrayPage[TagListResponse]:
         """
         Get the list of all agent tags that have been created.
 
@@ -90,8 +91,9 @@ class TagsResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return self._get(
+        return self._get_api_list(
             "/v1/tags/",
+            page=SyncArrayPage[TagListResponse],
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -110,7 +112,7 @@ class TagsResource(SyncAPIResource):
                     tag_list_params.TagListParams,
                 ),
             ),
-            cast_to=TagListResponse,
+            model=str,
         )
 
 
@@ -134,7 +136,7 @@ class AsyncTagsResource(AsyncAPIResource):
         """
         return AsyncTagsResourceWithStreamingResponse(self)
 
-    async def list(
+    def list(
         self,
         *,
         after: Optional[str] | Omit = omit,
@@ -150,7 +152,7 @@ class AsyncTagsResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> TagListResponse:
+    ) -> AsyncPaginator[TagListResponse, AsyncArrayPage[TagListResponse]]:
         """
         Get the list of all agent tags that have been created.
 
@@ -180,14 +182,15 @@ class AsyncTagsResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return await self._get(
+        return self._get_api_list(
             "/v1/tags/",
+            page=AsyncArrayPage[TagListResponse],
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
                 extra_body=extra_body,
                 timeout=timeout,
-                query=await async_maybe_transform(
+                query=maybe_transform(
                     {
                         "after": after,
                         "before": before,
@@ -200,7 +203,7 @@ class AsyncTagsResource(AsyncAPIResource):
                     tag_list_params.TagListParams,
                 ),
             ),
-            cast_to=TagListResponse,
+            model=str,
         )
 
 

letta_client/resources/templates/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .agents import (
+    AgentsResource,
+    AsyncAgentsResource,
+    AgentsResourceWithRawResponse,
+    AsyncAgentsResourceWithRawResponse,
+    AgentsResourceWithStreamingResponse,
+    AsyncAgentsResourceWithStreamingResponse,
+)
+from .templates import (
+    TemplatesResource,
+    AsyncTemplatesResource,
+    TemplatesResourceWithRawResponse,
+    AsyncTemplatesResourceWithRawResponse,
+    TemplatesResourceWithStreamingResponse,
+    AsyncTemplatesResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "AgentsResource",
+    "AsyncAgentsResource",
+    "AgentsResourceWithRawResponse",
+    "AsyncAgentsResourceWithRawResponse",
+    "AgentsResourceWithStreamingResponse",
+    "AsyncAgentsResourceWithStreamingResponse",
+    "TemplatesResource",
+    "AsyncTemplatesResource",
+    "TemplatesResourceWithRawResponse",
+    "AsyncTemplatesResourceWithRawResponse",
+    "TemplatesResourceWithStreamingResponse",
+    "AsyncTemplatesResourceWithStreamingResponse",
+]

letta_client/resources/templates/agents.py

@@ -0,0 +1,236 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Iterable
+
+import httpx
+
+from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, SequenceNotStr, 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.templates import agent_create_params
+
+__all__ = ["AgentsResource", "AsyncAgentsResource"]
+
+
+class AgentsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AgentsResourceWithRawResponse:
+        """
+        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/letta-ai/letta-python#accessing-raw-response-data-eg-headers
+        """
+        return AgentsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AgentsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/letta-ai/letta-python#with_streaming_response
+        """
+        return AgentsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        template_version: str,
+        *,
+        project_id: str,
+        agent_name: str | Omit = omit,
+        identity_ids: SequenceNotStr[str] | Omit = omit,
+        initial_message_sequence: Iterable[agent_create_params.InitialMessageSequence] | Omit = omit,
+        memory_variables: Dict[str, str] | Omit = omit,
+        tags: SequenceNotStr[str] | Omit = omit,
+        tool_variables: Dict[str, str] | 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,
+    ) -> None:
+        """
+        Creates an Agent or multiple Agents from a template
+
+        Args:
+          agent_name: The name of the agent, optional otherwise a random one will be assigned
+
+          identity_ids: The identity ids to assign to the agent
+
+          initial_message_sequence: Set an initial sequence of messages, if not provided, the agent will start with
+              the default message sequence, if an empty array is provided, the agent will
+              start with no messages
+
+          memory_variables: The memory variables to assign to the agent
+
+          tags: The tags to assign to the agent
+
+          tool_variables: The tool variables to assign to the agent
+
+          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 project_id:
+            raise ValueError(f"Expected a non-empty value for `project_id` but received {project_id!r}")
+        if not template_version:
+            raise ValueError(f"Expected a non-empty value for `template_version` but received {template_version!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._post(
+            f"/v1/templates/{project_id}/{template_version}/agents",
+            body=maybe_transform(
+                {
+                    "agent_name": agent_name,
+                    "identity_ids": identity_ids,
+                    "initial_message_sequence": initial_message_sequence,
+                    "memory_variables": memory_variables,
+                    "tags": tags,
+                    "tool_variables": tool_variables,
+                },
+                agent_create_params.AgentCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncAgentsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncAgentsResourceWithRawResponse:
+        """
+        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/letta-ai/letta-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncAgentsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAgentsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/letta-ai/letta-python#with_streaming_response
+        """
+        return AsyncAgentsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        template_version: str,
+        *,
+        project_id: str,
+        agent_name: str | Omit = omit,
+        identity_ids: SequenceNotStr[str] | Omit = omit,
+        initial_message_sequence: Iterable[agent_create_params.InitialMessageSequence] | Omit = omit,
+        memory_variables: Dict[str, str] | Omit = omit,
+        tags: SequenceNotStr[str] | Omit = omit,
+        tool_variables: Dict[str, str] | 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,
+    ) -> None:
+        """
+        Creates an Agent or multiple Agents from a template
+
+        Args:
+          agent_name: The name of the agent, optional otherwise a random one will be assigned
+
+          identity_ids: The identity ids to assign to the agent
+
+          initial_message_sequence: Set an initial sequence of messages, if not provided, the agent will start with
+              the default message sequence, if an empty array is provided, the agent will
+              start with no messages
+
+          memory_variables: The memory variables to assign to the agent
+
+          tags: The tags to assign to the agent
+
+          tool_variables: The tool variables to assign to the agent
+
+          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 project_id:
+            raise ValueError(f"Expected a non-empty value for `project_id` but received {project_id!r}")
+        if not template_version:
+            raise ValueError(f"Expected a non-empty value for `template_version` but received {template_version!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._post(
+            f"/v1/templates/{project_id}/{template_version}/agents",
+            body=await async_maybe_transform(
+                {
+                    "agent_name": agent_name,
+                    "identity_ids": identity_ids,
+                    "initial_message_sequence": initial_message_sequence,
+                    "memory_variables": memory_variables,
+                    "tags": tags,
+                    "tool_variables": tool_variables,
+                },
+                agent_create_params.AgentCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AgentsResourceWithRawResponse:
+    def __init__(self, agents: AgentsResource) -> None:
+        self._agents = agents
+
+        self.create = to_raw_response_wrapper(
+            agents.create,
+        )
+
+
+class AsyncAgentsResourceWithRawResponse:
+    def __init__(self, agents: AsyncAgentsResource) -> None:
+        self._agents = agents
+
+        self.create = async_to_raw_response_wrapper(
+            agents.create,
+        )
+
+
+class AgentsResourceWithStreamingResponse:
+    def __init__(self, agents: AgentsResource) -> None:
+        self._agents = agents
+
+        self.create = to_streamed_response_wrapper(
+            agents.create,
+        )
+
+
+class AsyncAgentsResourceWithStreamingResponse:
+    def __init__(self, agents: AsyncAgentsResource) -> None:
+        self._agents = agents
+
+        self.create = async_to_streamed_response_wrapper(
+            agents.create,
+        )

letta_client/resources/templates/templates.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .agents import (
+    AgentsResource,
+    AsyncAgentsResource,
+    AgentsResourceWithRawResponse,
+    AsyncAgentsResourceWithRawResponse,
+    AgentsResourceWithStreamingResponse,
+    AsyncAgentsResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["TemplatesResource", "AsyncTemplatesResource"]
+
+
+class TemplatesResource(SyncAPIResource):
+    @cached_property
+    def agents(self) -> AgentsResource:
+        return AgentsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> TemplatesResourceWithRawResponse:
+        """
+        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/letta-ai/letta-python#accessing-raw-response-data-eg-headers
+        """
+        return TemplatesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TemplatesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/letta-ai/letta-python#with_streaming_response
+        """
+        return TemplatesResourceWithStreamingResponse(self)
+
+
+class AsyncTemplatesResource(AsyncAPIResource):
+    @cached_property
+    def agents(self) -> AsyncAgentsResource:
+        return AsyncAgentsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncTemplatesResourceWithRawResponse:
+        """
+        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/letta-ai/letta-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncTemplatesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTemplatesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/letta-ai/letta-python#with_streaming_response
+        """
+        return AsyncTemplatesResourceWithStreamingResponse(self)
+
+
+class TemplatesResourceWithRawResponse:
+    def __init__(self, templates: TemplatesResource) -> None:
+        self._templates = templates
+
+    @cached_property
+    def agents(self) -> AgentsResourceWithRawResponse:
+        return AgentsResourceWithRawResponse(self._templates.agents)
+
+
+class AsyncTemplatesResourceWithRawResponse:
+    def __init__(self, templates: AsyncTemplatesResource) -> None:
+        self._templates = templates
+
+    @cached_property
+    def agents(self) -> AsyncAgentsResourceWithRawResponse:
+        return AsyncAgentsResourceWithRawResponse(self._templates.agents)
+
+
+class TemplatesResourceWithStreamingResponse:
+    def __init__(self, templates: TemplatesResource) -> None:
+        self._templates = templates
+
+    @cached_property
+    def agents(self) -> AgentsResourceWithStreamingResponse:
+        return AgentsResourceWithStreamingResponse(self._templates.agents)
+
+
+class AsyncTemplatesResourceWithStreamingResponse:
+    def __init__(self, templates: AsyncTemplatesResource) -> None:
+        self._templates = templates
+
+    @cached_property
+    def agents(self) -> AsyncAgentsResourceWithStreamingResponse:
+        return AsyncAgentsResourceWithStreamingResponse(self._templates.agents)