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

letta_sdk/types/step_list_messages_params.py → letta_client/types/steps/message_list_params.py

@@ -5,10 +5,10 @@ from __future__ import annotations
 from typing import Optional
 from typing_extensions import Literal, TypedDict
 
-__all__ = ["StepListMessagesParams"]
+__all__ = ["MessageListParams"]
 
 
-class StepListMessagesParams(TypedDict, total=False):
+class MessageListParams(TypedDict, total=False):
     after: Optional[str]
     """Message ID cursor for pagination.
 

letta_client/types/steps/message_list_response.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..agents.user_message import UserMessage
+from ..tool_return_message import ToolReturnMessage
+from ..agents.system_message import SystemMessage
+from ..agents.assistant_message import AssistantMessage
+from ..agents.reasoning_message import ReasoningMessage
+from ..agents.tool_call_message import ToolCallMessage
+from ..agents.approval_request_message import ApprovalRequestMessage
+from ..agents.hidden_reasoning_message import HiddenReasoningMessage
+from ..agents.approval_response_message import ApprovalResponseMessage
+
+__all__ = ["MessageListResponse"]
+
+MessageListResponse: TypeAlias = Annotated[
+    Union[
+        SystemMessage,
+        UserMessage,
+        ReasoningMessage,
+        HiddenReasoningMessage,
+        ToolCallMessage,
+        ToolReturnMessage,
+        AssistantMessage,
+        ApprovalRequestMessage,
+        ApprovalResponseMessage,
+    ],
+    PropertyInfo(discriminator="message_type"),
+]

letta_sdk/types/step_retrieve_metrics_response.py → letta_client/types/steps/metric_retrieve_response.py

@@ -2,12 +2,12 @@
 
 from typing import Optional
 
-from .._models import BaseModel
+from ..._models import BaseModel
 
-__all__ = ["StepRetrieveMetricsResponse"]
+__all__ = ["MetricRetrieveResponse"]
 
 
-class StepRetrieveMetricsResponse(BaseModel):
+class MetricRetrieveResponse(BaseModel):
     id: str
     """The id of the step this metric belongs to (matches steps.id)."""
 
@@ -17,9 +17,6 @@ class StepRetrieveMetricsResponse(BaseModel):
     base_template_id: Optional[str] = None
     """The base template ID that the step belongs to (cloud only)."""
 
-    job_id: Optional[str] = None
-    """The unique identifier of the job."""
-
     llm_request_ns: Optional[int] = None
     """Time spent on LLM requests in nanoseconds."""
 
@@ -32,6 +29,9 @@ class StepRetrieveMetricsResponse(BaseModel):
     provider_id: Optional[str] = None
     """The unique identifier of the provider."""
 
+    run_id: Optional[str] = None
+    """The unique identifier of the run."""
+
     step_ns: Optional[int] = None
     """Total time for the step in nanoseconds."""
 

{letta_sdk → letta_client}/types/tag_list_response.py

@@ -1,8 +1,7 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List
 from typing_extensions import TypeAlias
 
 __all__ = ["TagListResponse"]
 
-TagListResponse: TypeAlias = List[str]
+TagListResponse: TypeAlias = str

letta_client/types/templates/__init__.py

@@ -0,0 +1,5 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .agent_create_params import AgentCreateParams as AgentCreateParams

letta_sdk/types/template_create_agents_params.py → letta_client/types/templates/agent_create_params.py

@@ -5,13 +5,13 @@ from __future__ import annotations
 from typing import Dict, Iterable, Optional
 from typing_extensions import Literal, Required, TypedDict
 
-from .._types import SequenceNotStr
+from ..._types import SequenceNotStr
 
-__all__ = ["TemplateCreateAgentsParams", "InitialMessageSequence"]
+__all__ = ["AgentCreateParams", "InitialMessageSequence"]
 
 
-class TemplateCreateAgentsParams(TypedDict, total=False):
-    project: Required[str]
+class AgentCreateParams(TypedDict, total=False):
+    project_id: Required[str]
 
     agent_name: str
     """The name of the agent, optional otherwise a random one will be assigned"""

{letta_sdk → letta_client}/types/tool.py

@@ -28,6 +28,12 @@ class Tool(BaseModel):
     description: Optional[str] = None
     """The description of the tool."""
 
+    enable_parallel_execution: Optional[bool] = None
+    """
+    If set to True, then this tool will potentially be executed concurrently with
+    other tools. Default False.
+    """
+
     json_schema: Optional[Dict[str, object]] = None
     """The JSON schema of the function."""
 

{letta_sdk → letta_client}/types/tool_create_params.py

@@ -25,6 +25,12 @@ class ToolCreateParams(TypedDict, total=False):
     description: Optional[str]
     """The description of the tool."""
 
+    enable_parallel_execution: Optional[bool]
+    """
+    If set to True, then this tool will potentially be executed concurrently with
+    other tools. Default False.
+    """
+
     json_schema: Optional[Dict[str, object]]
     """
     The JSON schema of the function (auto-generated from source_code if not

{letta_sdk → letta_client}/types/tool_return_message.py

@@ -5,6 +5,7 @@ from datetime import datetime
 from typing_extensions import Literal
 
 from .._models import BaseModel
+from .agents.tool_return import ToolReturn
 
 __all__ = ["ToolReturnMessage"]
 
@@ -40,3 +41,5 @@ class ToolReturnMessage(BaseModel):
     stdout: Optional[List[str]] = None
 
     step_id: Optional[str] = None
+
+    tool_returns: Optional[List[ToolReturn]] = None

letta_sdk/types/tool_modify_params.py → letta_client/types/tool_update_params.py

@@ -10,10 +10,10 @@ from .._utils import PropertyInfo
 from .npm_requirement_param import NpmRequirementParam
 from .pip_requirement_param import PipRequirementParam
 
-__all__ = ["ToolModifyParams"]
+__all__ = ["ToolUpdateParams"]
 
 
-class ToolModifyParams(TypedDict, total=False):
+class ToolUpdateParams(TypedDict, total=False):
     args_json_schema: Optional[Dict[str, object]]
     """The args JSON schema of the function."""
 
@@ -23,6 +23,12 @@ class ToolModifyParams(TypedDict, total=False):
     description: Optional[str]
     """The description of the tool."""
 
+    enable_parallel_execution: Optional[bool]
+    """
+    If set to True, then this tool will potentially be executed concurrently with
+    other tools. Default False.
+    """
+
     json_schema: Optional[Dict[str, object]]
     """
     The JSON schema of the function (auto-generated from source_code if not

letta_sdk/types/tool_list_response.py → letta_client/types/tool_upsert_base_tools_response.py

@@ -5,6 +5,6 @@ from typing_extensions import TypeAlias
 
 from .tool import Tool
 
-__all__ = ["ToolListResponse"]
+__all__ = ["ToolUpsertBaseToolsResponse"]
 
-ToolListResponse: TypeAlias = List[Tool]
+ToolUpsertBaseToolsResponse: TypeAlias = List[Tool]

{letta_sdk → letta_client}/types/tool_upsert_params.py

@@ -25,6 +25,12 @@ class ToolUpsertParams(TypedDict, total=False):
     description: Optional[str]
     """The description of the tool."""
 
+    enable_parallel_execution: Optional[bool]
+    """
+    If set to True, then this tool will potentially be executed concurrently with
+    other tools. Default False.
+    """
+
     json_schema: Optional[Dict[str, object]]
     """
     The JSON schema of the function (auto-generated from source_code if not

{letta_client-1.0.0a6.dist-info → letta_client-1.0.0a8.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.3
 Name: letta-client
-Version: 1.0.0a6
-Summary: The official Python library for the letta-sdk API
+Version: 1.0.0a8
+Summary: The official Python library for the letta API
 Project-URL: Homepage, https://github.com/letta-ai/letta-python
 Project-URL: Repository, https://github.com/letta-ai/letta-python
-Author: Letta SDK
+Author: Letta
 License: Apache-2.0
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -33,12 +33,12 @@ Requires-Dist: aiohttp; extra == 'aiohttp'
 Requires-Dist: httpx-aiohttp>=0.1.9; extra == 'aiohttp'
 Description-Content-Type: text/markdown
 
-# Letta SDK Python API library
+# Letta Python API library
 
 <!-- prettier-ignore -->
 [![PyPI version](https://img.shields.io/pypi/v/letta-client.svg?label=pypi%20(stable))](https://pypi.org/project/letta-client/)
 
-The Letta SDK Python library provides convenient access to the Letta SDK REST API from any Python 3.8+
+The Letta Python library provides convenient access to the Letta REST API from any Python 3.8+
 application. The library includes type definitions for all request params and response fields,
 and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).
 
@@ -61,15 +61,20 @@ The full API of this library can be found in [api.md](https://github.com/letta-a
 
 ```python
 import os
-from letta_sdk import LettaSDK
+from letta_client import Letta
 
-client = LettaSDK(
-    api_key=os.environ.get("LETTA_SDK_API_KEY"),  # This is the default and can be omitted
-    # defaults to "production".
-    environment="environment_1",
+client = Letta(
+    api_key=os.environ.get("LETTA_API_KEY"),  # This is the default and can be omitted
+    # defaults to "cloud".
+    environment="local",
 )
 
-archive = client.archives.update(
+archive = client.archives.create(
+    embedding_config={
+        "embedding_dim": 0,
+        "embedding_endpoint_type": "openai",
+        "embedding_model": "embedding_model",
+    },
     name="name",
 )
 print(archive.id)
@@ -77,27 +82,32 @@ print(archive.id)
 
 While you can provide an `api_key` keyword argument,
 we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
-to add `LETTA_SDK_API_KEY="My API Key"` to your `.env` file
+to add `LETTA_API_KEY="My API Key"` to your `.env` file
 so that your API Key is not stored in source control.
 
 ## Async usage
 
-Simply import `AsyncLettaSDK` instead of `LettaSDK` and use `await` with each API call:
+Simply import `AsyncLetta` instead of `Letta` and use `await` with each API call:
 
 ```python
 import os
 import asyncio
-from letta_sdk import AsyncLettaSDK
+from letta_client import AsyncLetta
 
-client = AsyncLettaSDK(
-    api_key=os.environ.get("LETTA_SDK_API_KEY"),  # This is the default and can be omitted
-    # defaults to "production".
-    environment="environment_1",
+client = AsyncLetta(
+    api_key=os.environ.get("LETTA_API_KEY"),  # This is the default and can be omitted
+    # defaults to "cloud".
+    environment="local",
 )
 
 
 async def main() -> None:
-    archive = await client.archives.update(
+    archive = await client.archives.create(
+        embedding_config={
+            "embedding_dim": 0,
+            "embedding_endpoint_type": "openai",
+            "embedding_model": "embedding_model",
+        },
         name="name",
     )
     print(archive.id)
@@ -123,16 +133,21 @@ Then you can enable it by instantiating the client with `http_client=DefaultAioH
 
 ```python
 import asyncio
-from letta_sdk import DefaultAioHttpClient
-from letta_sdk import AsyncLettaSDK
+from letta_client import DefaultAioHttpClient
+from letta_client import AsyncLetta
 
 
 async def main() -> None:
-    async with AsyncLettaSDK(
+    async with AsyncLetta(
         api_key="My API Key",
         http_client=DefaultAioHttpClient(),
     ) as client:
-        archive = await client.archives.update(
+        archive = await client.archives.create(
+            embedding_config={
+                "embedding_dim": 0,
+                "embedding_endpoint_type": "openai",
+                "embedding_model": "embedding_model",
+            },
             name="name",
         )
         print(archive.id)
@@ -155,19 +170,19 @@ Typed requests and responses provide autocomplete and documentation within your
 Nested parameters are dictionaries, typed using `TypedDict`, for example:
 
 ```python
-from letta_sdk import LettaSDK
+from letta_client import Letta
 
-client = LettaSDK()
+client = Letta()
 
-server = client.tools.mcp.servers.update(
-    mcp_server_name="mcp_server_name",
-    stdio_config={
-        "args": ["string"],
-        "command": "command",
-        "server_name": "server_name",
+archive = client.archives.create(
+    embedding_config={
+        "embedding_dim": 0,
+        "embedding_endpoint_type": "openai",
+        "embedding_model": "embedding_model",
     },
+    name="name",
 )
-print(server.stdio_config)
+print(archive.embedding_config)
 ```
 
 ## File uploads
@@ -176,12 +191,12 @@ Request parameters that correspond to file uploads can be passed as `bytes`, or
 
 ```python
 from pathlib import Path
-from letta_sdk import LettaSDK
+from letta_client import Letta
 
-client = LettaSDK()
+client = Letta()
 
-client.sources.upload_file(
-    source_id="source_id",
+client.folders.files.upload(
+    folder_id="source-123e4567-e89b-42d3-8456-426614174000",
     file=Path("/path/to/file"),
 )
 ```
@@ -190,29 +205,34 @@ The async client uses the exact same interface. If you pass a [`PathLike`](https
 
 ## Handling errors
 
-When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `letta_sdk.APIConnectionError` is raised.
+When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `letta_client.APIConnectionError` is raised.
 
 When the API returns a non-success status code (that is, 4xx or 5xx
-response), a subclass of `letta_sdk.APIStatusError` is raised, containing `status_code` and `response` properties.
+response), a subclass of `letta_client.APIStatusError` is raised, containing `status_code` and `response` properties.
 
-All errors inherit from `letta_sdk.APIError`.
+All errors inherit from `letta_client.APIError`.
 
 ```python
-import letta_sdk
-from letta_sdk import LettaSDK
+import letta_client
+from letta_client import Letta
 
-client = LettaSDK()
+client = Letta()
 
 try:
-    client.archives.update(
+    client.archives.create(
+        embedding_config={
+            "embedding_dim": 0,
+            "embedding_endpoint_type": "openai",
+            "embedding_model": "embedding_model",
+        },
         name="name",
     )
-except letta_sdk.APIConnectionError as e:
+except letta_client.APIConnectionError as e:
     print("The server could not be reached")
     print(e.__cause__)  # an underlying Exception, likely raised within httpx.
-except letta_sdk.RateLimitError as e:
+except letta_client.RateLimitError as e:
     print("A 429 status code was received; we should back off a bit.")
-except letta_sdk.APIStatusError as e:
+except letta_client.APIStatusError as e:
     print("Another non-200-range status code was received")
     print(e.status_code)
     print(e.response)
@@ -240,16 +260,21 @@ Connection errors (for example, due to a network connectivity problem), 408 Requ
 You can use the `max_retries` option to configure or disable retry settings:
 
 ```python
-from letta_sdk import LettaSDK
+from letta_client import Letta
 
 # Configure the default for all requests:
-client = LettaSDK(
+client = Letta(
     # default is 2
     max_retries=0,
 )
 
 # Or, configure per-request:
-client.with_options(max_retries=5).archives.update(
+client.with_options(max_retries=5).archives.create(
+    embedding_config={
+        "embedding_dim": 0,
+        "embedding_endpoint_type": "openai",
+        "embedding_model": "embedding_model",
+    },
     name="name",
 )
 ```
@@ -260,21 +285,26 @@ By default requests time out after 1 minute. You can configure this with a `time
 which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object:
 
 ```python
-from letta_sdk import LettaSDK
+from letta_client import Letta
 
 # Configure the default for all requests:
-client = LettaSDK(
+client = Letta(
     # 20 seconds (default is 1 minute)
     timeout=20.0,
 )
 
 # More granular control:
-client = LettaSDK(
+client = Letta(
     timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
 )
 
 # Override per-request:
-client.with_options(timeout=5.0).archives.update(
+client.with_options(timeout=5.0).archives.create(
+    embedding_config={
+        "embedding_dim": 0,
+        "embedding_endpoint_type": "openai",
+        "embedding_model": "embedding_model",
+    },
     name="name",
 )
 ```
@@ -289,10 +319,10 @@ Note that requests that time out are [retried twice by default](https://github.c
 
 We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.
 
-You can enable logging by setting the environment variable `LETTA_SDK_LOG` to `info`.
+You can enable logging by setting the environment variable `LETTA_LOG` to `info`.
 
 ```shell
-$ export LETTA_SDK_LOG=info
+$ export LETTA_LOG=info
 ```
 
 Or to `debug` for more verbose logging.
@@ -314,21 +344,26 @@ if response.my_field is None:
 The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,
 
 ```py
-from letta_sdk import LettaSDK
-
-client = LettaSDK()
-response = client.archives.with_raw_response.update(
+from letta_client import Letta
+
+client = Letta()
+response = client.archives.with_raw_response.create(
+    embedding_config={
+        "embedding_dim": 0,
+        "embedding_endpoint_type": "openai",
+        "embedding_model": "embedding_model",
+    },
     name="name",
 )
 print(response.headers.get('X-My-Header'))
 
-archive = response.parse()  # get the object that `archives.update()` would have returned
+archive = response.parse()  # get the object that `archives.create()` would have returned
 print(archive.id)
 ```
 
-These methods return an [`APIResponse`](https://github.com/letta-ai/letta-python/tree/1.0-release/src/letta_sdk/_response.py) object.
+These methods return an [`APIResponse`](https://github.com/letta-ai/letta-python/tree/1.0-release/src/letta_client/_response.py) object.
 
-The async client returns an [`AsyncAPIResponse`](https://github.com/letta-ai/letta-python/tree/1.0-release/src/letta_sdk/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.
+The async client returns an [`AsyncAPIResponse`](https://github.com/letta-ai/letta-python/tree/1.0-release/src/letta_client/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.
 
 #### `.with_streaming_response`
 
@@ -337,7 +372,12 @@ The above interface eagerly reads the full response body when you make the reque
 To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
 
 ```python
-with client.archives.with_streaming_response.update(
+with client.archives.with_streaming_response.create(
+    embedding_config={
+        "embedding_dim": 0,
+        "embedding_endpoint_type": "openai",
+        "embedding_model": "embedding_model",
+    },
     name="name",
 ) as response:
     print(response.headers.get("X-My-Header"))
@@ -392,10 +432,10 @@ You can directly override the [httpx client](https://www.python-httpx.org/api/#c
 
 ```python
 import httpx
-from letta_sdk import LettaSDK, DefaultHttpxClient
+from letta_client import Letta, DefaultHttpxClient
 
-client = LettaSDK(
-    # Or use the `LETTA_SDK_BASE_URL` env var
+client = Letta(
+    # Or use the `LETTA_BASE_URL` env var
     base_url="http://my.test.server.example.com:8083",
     http_client=DefaultHttpxClient(
         proxy="http://my.test.proxy.example.com",
@@ -415,9 +455,9 @@ client.with_options(http_client=DefaultHttpxClient(...))
 By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.
 
 ```py
-from letta_sdk import LettaSDK
+from letta_client import Letta
 
-with LettaSDK() as client:
+with Letta() as client:
   # make requests here
   ...
 
@@ -443,8 +483,8 @@ If you've upgraded to the latest version but aren't seeing any new features you
 You can determine the version that is being used at runtime with:
 
 ```py
-import letta_sdk
-print(letta_sdk.__version__)
+import letta_client
+print(letta_client.__version__)
 ```
 
 ## Requirements