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

{letta_sdk → letta_client}/__init__.py

@@ -7,14 +7,14 @@ from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes
 from ._utils import file_from_path
 from ._client import (
     ENVIRONMENTS,
+    Letta,
     Client,
     Stream,
     Timeout,
-    LettaSDK,
     Transport,
+    AsyncLetta,
     AsyncClient,
     AsyncStream,
-    AsyncLettaSDK,
     RequestOptions,
 )
 from ._models import BaseModel
@@ -23,8 +23,8 @@ from ._response import APIResponse as APIResponse, AsyncAPIResponse as AsyncAPIR
 from ._constants import DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES, DEFAULT_CONNECTION_LIMITS
 from ._exceptions import (
     APIError,
+    LettaError,
     ConflictError,
-    LettaSDKError,
     NotFoundError,
     APIStatusError,
     RateLimitError,
@@ -52,7 +52,7 @@ __all__ = [
     "not_given",
     "Omit",
     "omit",
-    "LettaSDKError",
+    "LettaError",
     "APIError",
     "APIStatusError",
     "APITimeoutError",
@@ -72,8 +72,8 @@ __all__ = [
     "AsyncClient",
     "Stream",
     "AsyncStream",
-    "LettaSDK",
-    "AsyncLettaSDK",
+    "Letta",
+    "AsyncLetta",
     "ENVIRONMENTS",
     "file_from_path",
     "BaseModel",
@@ -93,12 +93,12 @@ _setup_logging()
 # Update the __module__ attribute for exported symbols so that
 # error messages point to this module instead of the module
 # it was originally defined in, e.g.
-# letta_sdk._exceptions.NotFoundError -> letta_sdk.NotFoundError
+# letta_client._exceptions.NotFoundError -> letta_client.NotFoundError
 __locals = locals()
 for __name in __all__:
     if not __name.startswith("__"):
         try:
-            __locals[__name].__module__ = "letta_sdk"
+            __locals[__name].__module__ = "letta_client"
         except (TypeError, AttributeError):
             # Some of our exported symbols are builtins which we can't set attributes for.
             pass

{letta_sdk → letta_client}/_base_client.py

@@ -389,7 +389,7 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
 
         if max_retries is None:  # pyright: ignore[reportUnnecessaryComparison]
             raise TypeError(
-                "max_retries cannot be None. If you want to disable retries, pass `0`; if you want unlimited retries, pass `math.inf` or a very high number; if you want the default behavior, pass `letta_sdk.DEFAULT_MAX_RETRIES`"
+                "max_retries cannot be None. If you want to disable retries, pass `0`; if you want unlimited retries, pass `math.inf` or a very high number; if you want the default behavior, pass `letta_client.DEFAULT_MAX_RETRIES`"
             )
 
     def _enforce_trailing_slash(self, url: URL) -> URL:

{letta_sdk → letta_client}/_client.py

@@ -11,7 +11,10 @@ import httpx
 from . import _exceptions
 from ._qs import Querystring
 from ._types import (
+    Body,
     Omit,
+    Query,
+    Headers,
     Timeout,
     NotGiven,
     Transport,
@@ -21,38 +24,32 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import (
-    jobs,
-    runs,
-    tags,
-    steps,
-    blocks,
-    health,
-    models,
-    folders,
-    archives,
-    projects,
-    providers,
-    telemetry,
-    templates,
-    embeddings,
-    identities,
-    client_side_access_tokens,
+from ._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
 )
+from .resources import tags, tools, archives
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
-from ._exceptions import LettaSDKError, APIStatusError
+from ._exceptions import LettaError, APIStatusError
 from ._base_client import (
     DEFAULT_MAX_RETRIES,
     SyncAPIClient,
     AsyncAPIClient,
+    make_request_options,
 )
-from .resources.tools import tools
+from .resources.runs import runs
+from .resources.steps import steps
 from .resources.agents import agents
+from .resources.blocks import blocks
 from .resources.groups import groups
-from .resources.sources import sources
-from .resources.messages import messages
-from .resources.voice_beta import voice_beta
-from .resources._internal_templates import _internal_templates
+from .resources.models import models
+from .resources.batches import batches
+from .resources.folders import folders
+from .resources.templates import templates
+from .resources.identities import identities
+from .types.health_response import HealthResponse
 
 __all__ = [
     "ENVIRONMENTS",
@@ -60,55 +57,45 @@ __all__ = [
     "Transport",
     "ProxiesTypes",
     "RequestOptions",
-    "LettaSDK",
-    "AsyncLettaSDK",
+    "Letta",
+    "AsyncLetta",
     "Client",
     "AsyncClient",
 ]
 
 ENVIRONMENTS: Dict[str, str] = {
-    "production": "https://app.letta.com",
-    "environment_1": "http://localhost:8283",
+    "cloud": "https://app.letta.com",
+    "local": "http://localhost:8283",
 }
 
 
-class LettaSDK(SyncAPIClient):
+class Letta(SyncAPIClient):
     archives: archives.ArchivesResource
     tools: tools.ToolsResource
-    sources: sources.SourcesResource
     folders: folders.FoldersResource
     agents: agents.AgentsResource
     groups: groups.GroupsResource
     identities: identities.IdentitiesResource
-    _internal_templates: _internal_templates._InternalTemplatesResource
     models: models.ModelsResource
     blocks: blocks.BlocksResource
-    jobs: jobs.JobsResource
-    health: health.HealthResource
-    providers: providers.ProvidersResource
     runs: runs.RunsResource
     steps: steps.StepsResource
     tags: tags.TagsResource
-    telemetry: telemetry.TelemetryResource
-    messages: messages.MessagesResource
-    voice_beta: voice_beta.VoiceBetaResource
-    embeddings: embeddings.EmbeddingsResource
+    batches: batches.BatchesResource
     templates: templates.TemplatesResource
-    client_side_access_tokens: client_side_access_tokens.ClientSideAccessTokensResource
-    projects: projects.ProjectsResource
-    with_raw_response: LettaSDKWithRawResponse
-    with_streaming_response: LettaSDKWithStreamedResponse
+    with_raw_response: LettaWithRawResponse
+    with_streaming_response: LettaWithStreamedResponse
 
     # client options
     api_key: str
 
-    _environment: Literal["production", "environment_1"] | NotGiven
+    _environment: Literal["cloud", "local"] | NotGiven
 
     def __init__(
         self,
         *,
         api_key: str | None = None,
-        environment: Literal["production", "environment_1"] | NotGiven = not_given,
+        environment: Literal["cloud", "local"] | NotGiven = not_given,
         base_url: str | httpx.URL | None | NotGiven = not_given,
         timeout: float | Timeout | None | NotGiven = not_given,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -128,28 +115,28 @@ class LettaSDK(SyncAPIClient):
         # part of our public interface in the future.
         _strict_response_validation: bool = False,
     ) -> None:
-        """Construct a new synchronous LettaSDK client instance.
+        """Construct a new synchronous Letta client instance.
 
-        This automatically infers the `api_key` argument from the `LETTA_SDK_API_KEY` environment variable if it is not provided.
+        This automatically infers the `api_key` argument from the `LETTA_API_KEY` environment variable if it is not provided.
         """
         if api_key is None:
-            api_key = os.environ.get("LETTA_SDK_API_KEY")
+            api_key = os.environ.get("LETTA_API_KEY")
         if api_key is None:
-            raise LettaSDKError(
-                "The api_key client option must be set either by passing api_key to the client or by setting the LETTA_SDK_API_KEY environment variable"
+            raise LettaError(
+                "The api_key client option must be set either by passing api_key to the client or by setting the LETTA_API_KEY environment variable"
             )
         self.api_key = api_key
 
         self._environment = environment
 
-        base_url_env = os.environ.get("LETTA_SDK_BASE_URL")
+        base_url_env = os.environ.get("LETTA_BASE_URL")
         if is_given(base_url) and base_url is not None:
             # cast required because mypy doesn't understand the type narrowing
             base_url = cast("str | httpx.URL", base_url)  # pyright: ignore[reportUnnecessaryCast]
         elif is_given(environment):
             if base_url_env and base_url is not None:
                 raise ValueError(
-                    "Ambiguous URL; The `LETTA_SDK_BASE_URL` env var and the `environment` argument are given. If you want to use the environment, you must pass base_url=None",
+                    "Ambiguous URL; The `LETTA_BASE_URL` env var and the `environment` argument are given. If you want to use the environment, you must pass base_url=None",
                 )
 
             try:
@@ -159,7 +146,7 @@ class LettaSDK(SyncAPIClient):
         elif base_url_env is not None:
             base_url = base_url_env
         else:
-            self._environment = environment = "production"
+            self._environment = environment = "cloud"
 
             try:
                 base_url = ENVIRONMENTS[environment]
@@ -179,29 +166,19 @@ class LettaSDK(SyncAPIClient):
 
         self.archives = archives.ArchivesResource(self)
         self.tools = tools.ToolsResource(self)
-        self.sources = sources.SourcesResource(self)
         self.folders = folders.FoldersResource(self)
         self.agents = agents.AgentsResource(self)
         self.groups = groups.GroupsResource(self)
         self.identities = identities.IdentitiesResource(self)
-        self._internal_templates = _internal_templates._InternalTemplatesResource(self)
         self.models = models.ModelsResource(self)
         self.blocks = blocks.BlocksResource(self)
-        self.jobs = jobs.JobsResource(self)
-        self.health = health.HealthResource(self)
-        self.providers = providers.ProvidersResource(self)
         self.runs = runs.RunsResource(self)
         self.steps = steps.StepsResource(self)
         self.tags = tags.TagsResource(self)
-        self.telemetry = telemetry.TelemetryResource(self)
-        self.messages = messages.MessagesResource(self)
-        self.voice_beta = voice_beta.VoiceBetaResource(self)
-        self.embeddings = embeddings.EmbeddingsResource(self)
+        self.batches = batches.BatchesResource(self)
         self.templates = templates.TemplatesResource(self)
-        self.client_side_access_tokens = client_side_access_tokens.ClientSideAccessTokensResource(self)
-        self.projects = projects.ProjectsResource(self)
-        self.with_raw_response = LettaSDKWithRawResponse(self)
-        self.with_streaming_response = LettaSDKWithStreamedResponse(self)
+        self.with_raw_response = LettaWithRawResponse(self)
+        self.with_streaming_response = LettaWithStreamedResponse(self)
 
     @property
     @override
@@ -227,7 +204,7 @@ class LettaSDK(SyncAPIClient):
         self,
         *,
         api_key: str | None = None,
-        environment: Literal["production", "environment_1"] | None = None,
+        environment: Literal["cloud", "local"] | None = None,
         base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = not_given,
         http_client: httpx.Client | None = None,
@@ -276,6 +253,25 @@ class LettaSDK(SyncAPIClient):
     # client.with_options(timeout=10).foo.create(...)
     with_options = copy
 
+    def health(
+        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,
+    ) -> HealthResponse:
+        """Check Health"""
+        return self.get(
+            "/v1/health/",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=HealthResponse,
+        )
+
     @override
     def _make_status_error(
         self,
@@ -310,43 +306,33 @@ class LettaSDK(SyncAPIClient):
         return APIStatusError(err_msg, response=response, body=body)
 
 
-class AsyncLettaSDK(AsyncAPIClient):
+class AsyncLetta(AsyncAPIClient):
     archives: archives.AsyncArchivesResource
     tools: tools.AsyncToolsResource
-    sources: sources.AsyncSourcesResource
     folders: folders.AsyncFoldersResource
     agents: agents.AsyncAgentsResource
     groups: groups.AsyncGroupsResource
     identities: identities.AsyncIdentitiesResource
-    _internal_templates: _internal_templates.AsyncInternalTemplatesResource
     models: models.AsyncModelsResource
     blocks: blocks.AsyncBlocksResource
-    jobs: jobs.AsyncJobsResource
-    health: health.AsyncHealthResource
-    providers: providers.AsyncProvidersResource
     runs: runs.AsyncRunsResource
     steps: steps.AsyncStepsResource
     tags: tags.AsyncTagsResource
-    telemetry: telemetry.AsyncTelemetryResource
-    messages: messages.AsyncMessagesResource
-    voice_beta: voice_beta.AsyncVoiceBetaResource
-    embeddings: embeddings.AsyncEmbeddingsResource
+    batches: batches.AsyncBatchesResource
     templates: templates.AsyncTemplatesResource
-    client_side_access_tokens: client_side_access_tokens.AsyncClientSideAccessTokensResource
-    projects: projects.AsyncProjectsResource
-    with_raw_response: AsyncLettaSDKWithRawResponse
-    with_streaming_response: AsyncLettaSDKWithStreamedResponse
+    with_raw_response: AsyncLettaWithRawResponse
+    with_streaming_response: AsyncLettaWithStreamedResponse
 
     # client options
     api_key: str
 
-    _environment: Literal["production", "environment_1"] | NotGiven
+    _environment: Literal["cloud", "local"] | NotGiven
 
     def __init__(
         self,
         *,
         api_key: str | None = None,
-        environment: Literal["production", "environment_1"] | NotGiven = not_given,
+        environment: Literal["cloud", "local"] | NotGiven = not_given,
         base_url: str | httpx.URL | None | NotGiven = not_given,
         timeout: float | Timeout | None | NotGiven = not_given,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -366,28 +352,28 @@ class AsyncLettaSDK(AsyncAPIClient):
         # part of our public interface in the future.
         _strict_response_validation: bool = False,
     ) -> None:
-        """Construct a new async AsyncLettaSDK client instance.
+        """Construct a new async AsyncLetta client instance.
 
-        This automatically infers the `api_key` argument from the `LETTA_SDK_API_KEY` environment variable if it is not provided.
+        This automatically infers the `api_key` argument from the `LETTA_API_KEY` environment variable if it is not provided.
         """
         if api_key is None:
-            api_key = os.environ.get("LETTA_SDK_API_KEY")
+            api_key = os.environ.get("LETTA_API_KEY")
         if api_key is None:
-            raise LettaSDKError(
-                "The api_key client option must be set either by passing api_key to the client or by setting the LETTA_SDK_API_KEY environment variable"
+            raise LettaError(
+                "The api_key client option must be set either by passing api_key to the client or by setting the LETTA_API_KEY environment variable"
             )
         self.api_key = api_key
 
         self._environment = environment
 
-        base_url_env = os.environ.get("LETTA_SDK_BASE_URL")
+        base_url_env = os.environ.get("LETTA_BASE_URL")
         if is_given(base_url) and base_url is not None:
             # cast required because mypy doesn't understand the type narrowing
             base_url = cast("str | httpx.URL", base_url)  # pyright: ignore[reportUnnecessaryCast]
         elif is_given(environment):
             if base_url_env and base_url is not None:
                 raise ValueError(
-                    "Ambiguous URL; The `LETTA_SDK_BASE_URL` env var and the `environment` argument are given. If you want to use the environment, you must pass base_url=None",
+                    "Ambiguous URL; The `LETTA_BASE_URL` env var and the `environment` argument are given. If you want to use the environment, you must pass base_url=None",
                 )
 
             try:
@@ -397,7 +383,7 @@ class AsyncLettaSDK(AsyncAPIClient):
         elif base_url_env is not None:
             base_url = base_url_env
         else:
-            self._environment = environment = "production"
+            self._environment = environment = "cloud"
 
             try:
                 base_url = ENVIRONMENTS[environment]
@@ -417,29 +403,19 @@ class AsyncLettaSDK(AsyncAPIClient):
 
         self.archives = archives.AsyncArchivesResource(self)
         self.tools = tools.AsyncToolsResource(self)
-        self.sources = sources.AsyncSourcesResource(self)
         self.folders = folders.AsyncFoldersResource(self)
         self.agents = agents.AsyncAgentsResource(self)
         self.groups = groups.AsyncGroupsResource(self)
         self.identities = identities.AsyncIdentitiesResource(self)
-        self._internal_templates = _internal_templates.AsyncInternalTemplatesResource(self)
         self.models = models.AsyncModelsResource(self)
         self.blocks = blocks.AsyncBlocksResource(self)
-        self.jobs = jobs.AsyncJobsResource(self)
-        self.health = health.AsyncHealthResource(self)
-        self.providers = providers.AsyncProvidersResource(self)
         self.runs = runs.AsyncRunsResource(self)
         self.steps = steps.AsyncStepsResource(self)
         self.tags = tags.AsyncTagsResource(self)
-        self.telemetry = telemetry.AsyncTelemetryResource(self)
-        self.messages = messages.AsyncMessagesResource(self)
-        self.voice_beta = voice_beta.AsyncVoiceBetaResource(self)
-        self.embeddings = embeddings.AsyncEmbeddingsResource(self)
+        self.batches = batches.AsyncBatchesResource(self)
         self.templates = templates.AsyncTemplatesResource(self)
-        self.client_side_access_tokens = client_side_access_tokens.AsyncClientSideAccessTokensResource(self)
-        self.projects = projects.AsyncProjectsResource(self)
-        self.with_raw_response = AsyncLettaSDKWithRawResponse(self)
-        self.with_streaming_response = AsyncLettaSDKWithStreamedResponse(self)
+        self.with_raw_response = AsyncLettaWithRawResponse(self)
+        self.with_streaming_response = AsyncLettaWithStreamedResponse(self)
 
     @property
     @override
@@ -465,7 +441,7 @@ class AsyncLettaSDK(AsyncAPIClient):
         self,
         *,
         api_key: str | None = None,
-        environment: Literal["production", "environment_1"] | None = None,
+        environment: Literal["cloud", "local"] | None = None,
         base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = not_given,
         http_client: httpx.AsyncClient | None = None,
@@ -514,6 +490,25 @@ class AsyncLettaSDK(AsyncAPIClient):
     # client.with_options(timeout=10).foo.create(...)
     with_options = copy
 
+    async def health(
+        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,
+    ) -> HealthResponse:
+        """Check Health"""
+        return await self.get(
+            "/v1/health/",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=HealthResponse,
+        )
+
     @override
     def _make_status_error(
         self,
@@ -548,132 +543,90 @@ class AsyncLettaSDK(AsyncAPIClient):
         return APIStatusError(err_msg, response=response, body=body)
 
 
-class LettaSDKWithRawResponse:
-    def __init__(self, client: LettaSDK) -> None:
+class LettaWithRawResponse:
+    def __init__(self, client: Letta) -> None:
         self.archives = archives.ArchivesResourceWithRawResponse(client.archives)
         self.tools = tools.ToolsResourceWithRawResponse(client.tools)
-        self.sources = sources.SourcesResourceWithRawResponse(client.sources)
         self.folders = folders.FoldersResourceWithRawResponse(client.folders)
         self.agents = agents.AgentsResourceWithRawResponse(client.agents)
         self.groups = groups.GroupsResourceWithRawResponse(client.groups)
         self.identities = identities.IdentitiesResourceWithRawResponse(client.identities)
-        self._internal_templates = _internal_templates._InternalTemplatesResourceWithRawResponse(
-            client._internal_templates
-        )
         self.models = models.ModelsResourceWithRawResponse(client.models)
         self.blocks = blocks.BlocksResourceWithRawResponse(client.blocks)
-        self.jobs = jobs.JobsResourceWithRawResponse(client.jobs)
-        self.health = health.HealthResourceWithRawResponse(client.health)
-        self.providers = providers.ProvidersResourceWithRawResponse(client.providers)
         self.runs = runs.RunsResourceWithRawResponse(client.runs)
         self.steps = steps.StepsResourceWithRawResponse(client.steps)
         self.tags = tags.TagsResourceWithRawResponse(client.tags)
-        self.telemetry = telemetry.TelemetryResourceWithRawResponse(client.telemetry)
-        self.messages = messages.MessagesResourceWithRawResponse(client.messages)
-        self.voice_beta = voice_beta.VoiceBetaResourceWithRawResponse(client.voice_beta)
-        self.embeddings = embeddings.EmbeddingsResourceWithRawResponse(client.embeddings)
+        self.batches = batches.BatchesResourceWithRawResponse(client.batches)
         self.templates = templates.TemplatesResourceWithRawResponse(client.templates)
-        self.client_side_access_tokens = client_side_access_tokens.ClientSideAccessTokensResourceWithRawResponse(
-            client.client_side_access_tokens
+
+        self.health = to_raw_response_wrapper(
+            client.health,
         )
-        self.projects = projects.ProjectsResourceWithRawResponse(client.projects)
 
 
-class AsyncLettaSDKWithRawResponse:
-    def __init__(self, client: AsyncLettaSDK) -> None:
+class AsyncLettaWithRawResponse:
+    def __init__(self, client: AsyncLetta) -> None:
         self.archives = archives.AsyncArchivesResourceWithRawResponse(client.archives)
         self.tools = tools.AsyncToolsResourceWithRawResponse(client.tools)
-        self.sources = sources.AsyncSourcesResourceWithRawResponse(client.sources)
         self.folders = folders.AsyncFoldersResourceWithRawResponse(client.folders)
         self.agents = agents.AsyncAgentsResourceWithRawResponse(client.agents)
         self.groups = groups.AsyncGroupsResourceWithRawResponse(client.groups)
         self.identities = identities.AsyncIdentitiesResourceWithRawResponse(client.identities)
-        self._internal_templates = _internal_templates.AsyncInternalTemplatesResourceWithRawResponse(
-            client._internal_templates
-        )
         self.models = models.AsyncModelsResourceWithRawResponse(client.models)
         self.blocks = blocks.AsyncBlocksResourceWithRawResponse(client.blocks)
-        self.jobs = jobs.AsyncJobsResourceWithRawResponse(client.jobs)
-        self.health = health.AsyncHealthResourceWithRawResponse(client.health)
-        self.providers = providers.AsyncProvidersResourceWithRawResponse(client.providers)
         self.runs = runs.AsyncRunsResourceWithRawResponse(client.runs)
         self.steps = steps.AsyncStepsResourceWithRawResponse(client.steps)
         self.tags = tags.AsyncTagsResourceWithRawResponse(client.tags)
-        self.telemetry = telemetry.AsyncTelemetryResourceWithRawResponse(client.telemetry)
-        self.messages = messages.AsyncMessagesResourceWithRawResponse(client.messages)
-        self.voice_beta = voice_beta.AsyncVoiceBetaResourceWithRawResponse(client.voice_beta)
-        self.embeddings = embeddings.AsyncEmbeddingsResourceWithRawResponse(client.embeddings)
+        self.batches = batches.AsyncBatchesResourceWithRawResponse(client.batches)
         self.templates = templates.AsyncTemplatesResourceWithRawResponse(client.templates)
-        self.client_side_access_tokens = client_side_access_tokens.AsyncClientSideAccessTokensResourceWithRawResponse(
-            client.client_side_access_tokens
+
+        self.health = async_to_raw_response_wrapper(
+            client.health,
         )
-        self.projects = projects.AsyncProjectsResourceWithRawResponse(client.projects)
 
 
-class LettaSDKWithStreamedResponse:
-    def __init__(self, client: LettaSDK) -> None:
+class LettaWithStreamedResponse:
+    def __init__(self, client: Letta) -> None:
         self.archives = archives.ArchivesResourceWithStreamingResponse(client.archives)
         self.tools = tools.ToolsResourceWithStreamingResponse(client.tools)
-        self.sources = sources.SourcesResourceWithStreamingResponse(client.sources)
         self.folders = folders.FoldersResourceWithStreamingResponse(client.folders)
         self.agents = agents.AgentsResourceWithStreamingResponse(client.agents)
         self.groups = groups.GroupsResourceWithStreamingResponse(client.groups)
         self.identities = identities.IdentitiesResourceWithStreamingResponse(client.identities)
-        self._internal_templates = _internal_templates._InternalTemplatesResourceWithStreamingResponse(
-            client._internal_templates
-        )
         self.models = models.ModelsResourceWithStreamingResponse(client.models)
         self.blocks = blocks.BlocksResourceWithStreamingResponse(client.blocks)
-        self.jobs = jobs.JobsResourceWithStreamingResponse(client.jobs)
-        self.health = health.HealthResourceWithStreamingResponse(client.health)
-        self.providers = providers.ProvidersResourceWithStreamingResponse(client.providers)
         self.runs = runs.RunsResourceWithStreamingResponse(client.runs)
         self.steps = steps.StepsResourceWithStreamingResponse(client.steps)
         self.tags = tags.TagsResourceWithStreamingResponse(client.tags)
-        self.telemetry = telemetry.TelemetryResourceWithStreamingResponse(client.telemetry)
-        self.messages = messages.MessagesResourceWithStreamingResponse(client.messages)
-        self.voice_beta = voice_beta.VoiceBetaResourceWithStreamingResponse(client.voice_beta)
-        self.embeddings = embeddings.EmbeddingsResourceWithStreamingResponse(client.embeddings)
+        self.batches = batches.BatchesResourceWithStreamingResponse(client.batches)
         self.templates = templates.TemplatesResourceWithStreamingResponse(client.templates)
-        self.client_side_access_tokens = client_side_access_tokens.ClientSideAccessTokensResourceWithStreamingResponse(
-            client.client_side_access_tokens
+
+        self.health = to_streamed_response_wrapper(
+            client.health,
         )
-        self.projects = projects.ProjectsResourceWithStreamingResponse(client.projects)
 
 
-class AsyncLettaSDKWithStreamedResponse:
-    def __init__(self, client: AsyncLettaSDK) -> None:
+class AsyncLettaWithStreamedResponse:
+    def __init__(self, client: AsyncLetta) -> None:
         self.archives = archives.AsyncArchivesResourceWithStreamingResponse(client.archives)
         self.tools = tools.AsyncToolsResourceWithStreamingResponse(client.tools)
-        self.sources = sources.AsyncSourcesResourceWithStreamingResponse(client.sources)
         self.folders = folders.AsyncFoldersResourceWithStreamingResponse(client.folders)
         self.agents = agents.AsyncAgentsResourceWithStreamingResponse(client.agents)
         self.groups = groups.AsyncGroupsResourceWithStreamingResponse(client.groups)
         self.identities = identities.AsyncIdentitiesResourceWithStreamingResponse(client.identities)
-        self._internal_templates = _internal_templates.AsyncInternalTemplatesResourceWithStreamingResponse(
-            client._internal_templates
-        )
         self.models = models.AsyncModelsResourceWithStreamingResponse(client.models)
         self.blocks = blocks.AsyncBlocksResourceWithStreamingResponse(client.blocks)
-        self.jobs = jobs.AsyncJobsResourceWithStreamingResponse(client.jobs)
-        self.health = health.AsyncHealthResourceWithStreamingResponse(client.health)
-        self.providers = providers.AsyncProvidersResourceWithStreamingResponse(client.providers)
         self.runs = runs.AsyncRunsResourceWithStreamingResponse(client.runs)
         self.steps = steps.AsyncStepsResourceWithStreamingResponse(client.steps)
         self.tags = tags.AsyncTagsResourceWithStreamingResponse(client.tags)
-        self.telemetry = telemetry.AsyncTelemetryResourceWithStreamingResponse(client.telemetry)
-        self.messages = messages.AsyncMessagesResourceWithStreamingResponse(client.messages)
-        self.voice_beta = voice_beta.AsyncVoiceBetaResourceWithStreamingResponse(client.voice_beta)
-        self.embeddings = embeddings.AsyncEmbeddingsResourceWithStreamingResponse(client.embeddings)
+        self.batches = batches.AsyncBatchesResourceWithStreamingResponse(client.batches)
         self.templates = templates.AsyncTemplatesResourceWithStreamingResponse(client.templates)
-        self.client_side_access_tokens = (
-            client_side_access_tokens.AsyncClientSideAccessTokensResourceWithStreamingResponse(
-                client.client_side_access_tokens
-            )
+
+        self.health = async_to_streamed_response_wrapper(
+            client.health,
         )
-        self.projects = projects.AsyncProjectsResourceWithStreamingResponse(client.projects)
 
 
-Client = LettaSDK
+Client = Letta
 
-AsyncClient = AsyncLettaSDK
+AsyncClient = AsyncLetta

{letta_sdk → letta_client}/_exceptions.py

@@ -18,11 +18,11 @@ __all__ = [
 ]
 
 
-class LettaSDKError(Exception):
+class LettaError(Exception):
     pass
 
 
-class APIError(LettaSDKError):
+class APIError(LettaError):
     message: str
     request: httpx.Request