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

letta_sdk/resources/tools/__init__.py

@@ -1,47 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from .mcp import (
-    McpResource,
-    AsyncMcpResource,
-    McpResourceWithRawResponse,
-    AsyncMcpResourceWithRawResponse,
-    McpResourceWithStreamingResponse,
-    AsyncMcpResourceWithStreamingResponse,
-)
-from .tools import (
-    ToolsResource,
-    AsyncToolsResource,
-    ToolsResourceWithRawResponse,
-    AsyncToolsResourceWithRawResponse,
-    ToolsResourceWithStreamingResponse,
-    AsyncToolsResourceWithStreamingResponse,
-)
-from .composio import (
-    ComposioResource,
-    AsyncComposioResource,
-    ComposioResourceWithRawResponse,
-    AsyncComposioResourceWithRawResponse,
-    ComposioResourceWithStreamingResponse,
-    AsyncComposioResourceWithStreamingResponse,
-)
-
-__all__ = [
-    "ComposioResource",
-    "AsyncComposioResource",
-    "ComposioResourceWithRawResponse",
-    "AsyncComposioResourceWithRawResponse",
-    "ComposioResourceWithStreamingResponse",
-    "AsyncComposioResourceWithStreamingResponse",
-    "McpResource",
-    "AsyncMcpResource",
-    "McpResourceWithRawResponse",
-    "AsyncMcpResourceWithRawResponse",
-    "McpResourceWithStreamingResponse",
-    "AsyncMcpResourceWithStreamingResponse",
-    "ToolsResource",
-    "AsyncToolsResource",
-    "ToolsResourceWithRawResponse",
-    "AsyncToolsResourceWithRawResponse",
-    "ToolsResourceWithStreamingResponse",
-    "AsyncToolsResourceWithStreamingResponse",
-]

letta_sdk/resources/tools/composio/__init__.py

@@ -1,33 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from .apps import (
-    AppsResource,
-    AsyncAppsResource,
-    AppsResourceWithRawResponse,
-    AsyncAppsResourceWithRawResponse,
-    AppsResourceWithStreamingResponse,
-    AsyncAppsResourceWithStreamingResponse,
-)
-from .composio import (
-    ComposioResource,
-    AsyncComposioResource,
-    ComposioResourceWithRawResponse,
-    AsyncComposioResourceWithRawResponse,
-    ComposioResourceWithStreamingResponse,
-    AsyncComposioResourceWithStreamingResponse,
-)
-
-__all__ = [
-    "AppsResource",
-    "AsyncAppsResource",
-    "AppsResourceWithRawResponse",
-    "AsyncAppsResourceWithRawResponse",
-    "AppsResourceWithStreamingResponse",
-    "AsyncAppsResourceWithStreamingResponse",
-    "ComposioResource",
-    "AsyncComposioResource",
-    "ComposioResourceWithRawResponse",
-    "AsyncComposioResourceWithRawResponse",
-    "ComposioResourceWithStreamingResponse",
-    "AsyncComposioResourceWithStreamingResponse",
-]

letta_sdk/resources/tools/composio/apps.py

@@ -1,214 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import httpx
-
-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.tools.composio.app_list_response import AppListResponse
-from ....types.tools.composio.app_list_actions_response import AppListActionsResponse
-
-__all__ = ["AppsResource", "AsyncAppsResource"]
-
-
-class AppsResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AppsResourceWithRawResponse:
-        """
-        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 AppsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AppsResourceWithStreamingResponse:
-        """
-        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 AppsResourceWithStreamingResponse(self)
-
-    def list(
-        self,
-        *,
-        # 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,
-    ) -> AppListResponse:
-        """Get a list of all Composio apps"""
-        return self._get(
-            "/v1/tools/composio/apps",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=AppListResponse,
-        )
-
-    def list_actions(
-        self,
-        composio_app_name: 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,
-    ) -> AppListActionsResponse:
-        """
-        Get a list of all Composio actions for a specific app
-
-        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 composio_app_name:
-            raise ValueError(f"Expected a non-empty value for `composio_app_name` but received {composio_app_name!r}")
-        return self._get(
-            f"/v1/tools/composio/apps/{composio_app_name}/actions",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=AppListActionsResponse,
-        )
-
-
-class AsyncAppsResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncAppsResourceWithRawResponse:
-        """
-        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 AsyncAppsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncAppsResourceWithStreamingResponse:
-        """
-        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 AsyncAppsResourceWithStreamingResponse(self)
-
-    async def list(
-        self,
-        *,
-        # 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,
-    ) -> AppListResponse:
-        """Get a list of all Composio apps"""
-        return await self._get(
-            "/v1/tools/composio/apps",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=AppListResponse,
-        )
-
-    async def list_actions(
-        self,
-        composio_app_name: 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,
-    ) -> AppListActionsResponse:
-        """
-        Get a list of all Composio actions for a specific app
-
-        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 composio_app_name:
-            raise ValueError(f"Expected a non-empty value for `composio_app_name` but received {composio_app_name!r}")
-        return await self._get(
-            f"/v1/tools/composio/apps/{composio_app_name}/actions",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=AppListActionsResponse,
-        )
-
-
-class AppsResourceWithRawResponse:
-    def __init__(self, apps: AppsResource) -> None:
-        self._apps = apps
-
-        self.list = to_raw_response_wrapper(
-            apps.list,
-        )
-        self.list_actions = to_raw_response_wrapper(
-            apps.list_actions,
-        )
-
-
-class AsyncAppsResourceWithRawResponse:
-    def __init__(self, apps: AsyncAppsResource) -> None:
-        self._apps = apps
-
-        self.list = async_to_raw_response_wrapper(
-            apps.list,
-        )
-        self.list_actions = async_to_raw_response_wrapper(
-            apps.list_actions,
-        )
-
-
-class AppsResourceWithStreamingResponse:
-    def __init__(self, apps: AppsResource) -> None:
-        self._apps = apps
-
-        self.list = to_streamed_response_wrapper(
-            apps.list,
-        )
-        self.list_actions = to_streamed_response_wrapper(
-            apps.list_actions,
-        )
-
-
-class AsyncAppsResourceWithStreamingResponse:
-    def __init__(self, apps: AsyncAppsResource) -> None:
-        self._apps = apps
-
-        self.list = async_to_streamed_response_wrapper(
-            apps.list,
-        )
-        self.list_actions = async_to_streamed_response_wrapper(
-            apps.list_actions,
-        )

letta_sdk/resources/tools/composio/composio.py

@@ -1,201 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import httpx
-
-from .apps import (
-    AppsResource,
-    AsyncAppsResource,
-    AppsResourceWithRawResponse,
-    AsyncAppsResourceWithRawResponse,
-    AppsResourceWithStreamingResponse,
-    AsyncAppsResourceWithStreamingResponse,
-)
-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 ....types.tool import Tool
-from ...._base_client import make_request_options
-
-__all__ = ["ComposioResource", "AsyncComposioResource"]
-
-
-class ComposioResource(SyncAPIResource):
-    @cached_property
-    def apps(self) -> AppsResource:
-        return AppsResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> ComposioResourceWithRawResponse:
-        """
-        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 ComposioResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> ComposioResourceWithStreamingResponse:
-        """
-        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 ComposioResourceWithStreamingResponse(self)
-
-    def add(
-        self,
-        composio_action_name: 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,
-    ) -> Tool:
-        """
-        Add a new Composio tool by action name (Composio refers to each tool as an
-        `Action`)
-
-        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 composio_action_name:
-            raise ValueError(
-                f"Expected a non-empty value for `composio_action_name` but received {composio_action_name!r}"
-            )
-        return self._post(
-            f"/v1/tools/composio/{composio_action_name}",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Tool,
-        )
-
-
-class AsyncComposioResource(AsyncAPIResource):
-    @cached_property
-    def apps(self) -> AsyncAppsResource:
-        return AsyncAppsResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AsyncComposioResourceWithRawResponse:
-        """
-        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 AsyncComposioResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncComposioResourceWithStreamingResponse:
-        """
-        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 AsyncComposioResourceWithStreamingResponse(self)
-
-    async def add(
-        self,
-        composio_action_name: 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,
-    ) -> Tool:
-        """
-        Add a new Composio tool by action name (Composio refers to each tool as an
-        `Action`)
-
-        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 composio_action_name:
-            raise ValueError(
-                f"Expected a non-empty value for `composio_action_name` but received {composio_action_name!r}"
-            )
-        return await self._post(
-            f"/v1/tools/composio/{composio_action_name}",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Tool,
-        )
-
-
-class ComposioResourceWithRawResponse:
-    def __init__(self, composio: ComposioResource) -> None:
-        self._composio = composio
-
-        self.add = to_raw_response_wrapper(
-            composio.add,
-        )
-
-    @cached_property
-    def apps(self) -> AppsResourceWithRawResponse:
-        return AppsResourceWithRawResponse(self._composio.apps)
-
-
-class AsyncComposioResourceWithRawResponse:
-    def __init__(self, composio: AsyncComposioResource) -> None:
-        self._composio = composio
-
-        self.add = async_to_raw_response_wrapper(
-            composio.add,
-        )
-
-    @cached_property
-    def apps(self) -> AsyncAppsResourceWithRawResponse:
-        return AsyncAppsResourceWithRawResponse(self._composio.apps)
-
-
-class ComposioResourceWithStreamingResponse:
-    def __init__(self, composio: ComposioResource) -> None:
-        self._composio = composio
-
-        self.add = to_streamed_response_wrapper(
-            composio.add,
-        )
-
-    @cached_property
-    def apps(self) -> AppsResourceWithStreamingResponse:
-        return AppsResourceWithStreamingResponse(self._composio.apps)
-
-
-class AsyncComposioResourceWithStreamingResponse:
-    def __init__(self, composio: AsyncComposioResource) -> None:
-        self._composio = composio
-
-        self.add = async_to_streamed_response_wrapper(
-            composio.add,
-        )
-
-    @cached_property
-    def apps(self) -> AsyncAppsResourceWithStreamingResponse:
-        return AsyncAppsResourceWithStreamingResponse(self._composio.apps)

letta_sdk/resources/tools/mcp/__init__.py

@@ -1,47 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from .mcp import (
-    McpResource,
-    AsyncMcpResource,
-    McpResourceWithRawResponse,
-    AsyncMcpResourceWithRawResponse,
-    McpResourceWithStreamingResponse,
-    AsyncMcpResourceWithStreamingResponse,
-)
-from .oauth import (
-    OAuthResource,
-    AsyncOAuthResource,
-    OAuthResourceWithRawResponse,
-    AsyncOAuthResourceWithRawResponse,
-    OAuthResourceWithStreamingResponse,
-    AsyncOAuthResourceWithStreamingResponse,
-)
-from .servers import (
-    ServersResource,
-    AsyncServersResource,
-    ServersResourceWithRawResponse,
-    AsyncServersResourceWithRawResponse,
-    ServersResourceWithStreamingResponse,
-    AsyncServersResourceWithStreamingResponse,
-)
-
-__all__ = [
-    "ServersResource",
-    "AsyncServersResource",
-    "ServersResourceWithRawResponse",
-    "AsyncServersResourceWithRawResponse",
-    "ServersResourceWithStreamingResponse",
-    "AsyncServersResourceWithStreamingResponse",
-    "OAuthResource",
-    "AsyncOAuthResource",
-    "OAuthResourceWithRawResponse",
-    "AsyncOAuthResourceWithRawResponse",
-    "OAuthResourceWithStreamingResponse",
-    "AsyncOAuthResourceWithStreamingResponse",
-    "McpResource",
-    "AsyncMcpResource",
-    "McpResourceWithRawResponse",
-    "AsyncMcpResourceWithRawResponse",
-    "McpResourceWithStreamingResponse",
-    "AsyncMcpResourceWithStreamingResponse",
-]

letta_sdk/resources/tools/mcp/mcp.py

@@ -1,134 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from .oauth import (
-    OAuthResource,
-    AsyncOAuthResource,
-    OAuthResourceWithRawResponse,
-    AsyncOAuthResourceWithRawResponse,
-    OAuthResourceWithStreamingResponse,
-    AsyncOAuthResourceWithStreamingResponse,
-)
-from ...._compat import cached_property
-from ...._resource import SyncAPIResource, AsyncAPIResource
-from .servers.servers import (
-    ServersResource,
-    AsyncServersResource,
-    ServersResourceWithRawResponse,
-    AsyncServersResourceWithRawResponse,
-    ServersResourceWithStreamingResponse,
-    AsyncServersResourceWithStreamingResponse,
-)
-
-__all__ = ["McpResource", "AsyncMcpResource"]
-
-
-class McpResource(SyncAPIResource):
-    @cached_property
-    def servers(self) -> ServersResource:
-        return ServersResource(self._client)
-
-    @cached_property
-    def oauth(self) -> OAuthResource:
-        return OAuthResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> McpResourceWithRawResponse:
-        """
-        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 McpResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> McpResourceWithStreamingResponse:
-        """
-        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 McpResourceWithStreamingResponse(self)
-
-
-class AsyncMcpResource(AsyncAPIResource):
-    @cached_property
-    def servers(self) -> AsyncServersResource:
-        return AsyncServersResource(self._client)
-
-    @cached_property
-    def oauth(self) -> AsyncOAuthResource:
-        return AsyncOAuthResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AsyncMcpResourceWithRawResponse:
-        """
-        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 AsyncMcpResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncMcpResourceWithStreamingResponse:
-        """
-        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 AsyncMcpResourceWithStreamingResponse(self)
-
-
-class McpResourceWithRawResponse:
-    def __init__(self, mcp: McpResource) -> None:
-        self._mcp = mcp
-
-    @cached_property
-    def servers(self) -> ServersResourceWithRawResponse:
-        return ServersResourceWithRawResponse(self._mcp.servers)
-
-    @cached_property
-    def oauth(self) -> OAuthResourceWithRawResponse:
-        return OAuthResourceWithRawResponse(self._mcp.oauth)
-
-
-class AsyncMcpResourceWithRawResponse:
-    def __init__(self, mcp: AsyncMcpResource) -> None:
-        self._mcp = mcp
-
-    @cached_property
-    def servers(self) -> AsyncServersResourceWithRawResponse:
-        return AsyncServersResourceWithRawResponse(self._mcp.servers)
-
-    @cached_property
-    def oauth(self) -> AsyncOAuthResourceWithRawResponse:
-        return AsyncOAuthResourceWithRawResponse(self._mcp.oauth)
-
-
-class McpResourceWithStreamingResponse:
-    def __init__(self, mcp: McpResource) -> None:
-        self._mcp = mcp
-
-    @cached_property
-    def servers(self) -> ServersResourceWithStreamingResponse:
-        return ServersResourceWithStreamingResponse(self._mcp.servers)
-
-    @cached_property
-    def oauth(self) -> OAuthResourceWithStreamingResponse:
-        return OAuthResourceWithStreamingResponse(self._mcp.oauth)
-
-
-class AsyncMcpResourceWithStreamingResponse:
-    def __init__(self, mcp: AsyncMcpResource) -> None:
-        self._mcp = mcp
-
-    @cached_property
-    def servers(self) -> AsyncServersResourceWithStreamingResponse:
-        return AsyncServersResourceWithStreamingResponse(self._mcp.servers)
-
-    @cached_property
-    def oauth(self) -> AsyncOAuthResourceWithStreamingResponse:
-        return AsyncOAuthResourceWithStreamingResponse(self._mcp.oauth)