letta-client 0.1.2__py3-none-any.whl → 0.1.6__py3-none-any.whl

letta/client.py

@@ -35,11 +35,11 @@ class Letta:
 
 
 
-        Defaults to LettaEnvironment.LETTA_HOSTED
+        Defaults to LettaEnvironment.LETTA_CLOUD
 
 
 
-    token : typing.Union[str, typing.Callable[[], str]]
+    token : typing.Optional[str]
     timeout : typing.Optional[float]
         The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
 
@@ -62,8 +62,8 @@ class Letta:
         self,
         *,
         base_url: typing.Optional[str] = None,
-        environment: LettaEnvironment = LettaEnvironment.LETTA_HOSTED,
-        token: typing.Union[str, typing.Callable[[], str]],
+        environment: LettaEnvironment = LettaEnvironment.LETTA_CLOUD,
+        token: typing.Optional[str] = None,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
         httpx_client: typing.Optional[httpx.Client] = None,
@@ -102,11 +102,11 @@ class AsyncLetta:
 
 
 
-        Defaults to LettaEnvironment.LETTA_HOSTED
+        Defaults to LettaEnvironment.LETTA_CLOUD
 
 
 
-    token : typing.Union[str, typing.Callable[[], str]]
+    token : typing.Optional[str]
     timeout : typing.Optional[float]
         The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
 
@@ -129,8 +129,8 @@ class AsyncLetta:
         self,
         *,
         base_url: typing.Optional[str] = None,
-        environment: LettaEnvironment = LettaEnvironment.LETTA_HOSTED,
-        token: typing.Union[str, typing.Callable[[], str]],
+        environment: LettaEnvironment = LettaEnvironment.LETTA_CLOUD,
+        token: typing.Optional[str] = None,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
         httpx_client: typing.Optional[httpx.AsyncClient] = None,

letta/core/client_wrapper.py

@@ -7,14 +7,8 @@ from .http_client import AsyncHttpClient
 
 
 class BaseClientWrapper:
-    def __init__(
-        self,
-        *,
-        token: typing.Union[str, typing.Callable[[], str]],
-        base_url: str,
-        timeout: typing.Optional[float] = None,
-    ):
-        self._token = token
+    def __init__(self, *, token: typing.Optional[str] = None, base_url: str, timeout: typing.Optional[float] = None):
+        self.token = token
         self._base_url = base_url
         self._timeout = timeout
 
@@ -22,17 +16,12 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "letta-client",
-            "X-Fern-SDK-Version": "0.1.2",
+            "X-Fern-SDK-Version": "0.1.6",
         }
-        headers["Authorization"] = f"Bearer {self._get_token()}"
+        if self.token is not None:
+            headers["Authorization"] = f"Bearer {self.token}"
         return headers
 
-    def _get_token(self) -> str:
-        if isinstance(self._token, str):
-            return self._token
-        else:
-            return self._token()
-
     def get_base_url(self) -> str:
         return self._base_url
 
@@ -44,7 +33,7 @@ class SyncClientWrapper(BaseClientWrapper):
     def __init__(
         self,
         *,
-        token: typing.Union[str, typing.Callable[[], str]],
+        token: typing.Optional[str] = None,
         base_url: str,
         timeout: typing.Optional[float] = None,
         httpx_client: httpx.Client,
@@ -62,7 +51,7 @@ class AsyncClientWrapper(BaseClientWrapper):
     def __init__(
         self,
         *,
-        token: typing.Union[str, typing.Callable[[], str]],
+        token: typing.Optional[str] = None,
         base_url: str,
         timeout: typing.Optional[float] = None,
         httpx_client: httpx.AsyncClient,

letta/environment.py

@@ -4,5 +4,5 @@ import enum
 
 
 class LettaEnvironment(enum.Enum):
-    LETTA_HOSTED = "https://app.letta.com"
+    LETTA_CLOUD = "https://app.letta.com"
     SELF_HOSTED = "http://localhost:8283"

letta/types/__init__.py

@@ -3,6 +3,7 @@
 from .action_model import ActionModel
 from .action_parameters_model import ActionParametersModel
 from .action_response_model import ActionResponseModel
+from .agent_environment_variable import AgentEnvironmentVariable
 from .agent_state import AgentState
 from .agent_state_tool_rules_item import AgentStateToolRulesItem
 from .agent_type import AgentType
@@ -49,21 +50,15 @@ from .job import Job
 from .job_status import JobStatus
 from .letta_request import LettaRequest
 from .letta_response import LettaResponse
-from .letta_response_assistant_message import LettaResponseAssistantMessage
-from .letta_response_letta_usage_statistics import LettaResponseLettaUsageStatistics
-from .letta_response_reasoning_message import LettaResponseReasoningMessage
-from .letta_response_system_message import LettaResponseSystemMessage
-from .letta_response_tool_call import LettaResponseToolCall
-from .letta_response_tool_call_delta import LettaResponseToolCallDelta
-from .letta_response_tool_call_message import LettaResponseToolCallMessage
-from .letta_response_tool_call_message_tool_call import LettaResponseToolCallMessageToolCall
-from .letta_response_tool_call_message_tool_call_one import LettaResponseToolCallMessageToolCallOne
-from .letta_response_tool_call_message_tool_call_zero import LettaResponseToolCallMessageToolCallZero
-from .letta_response_tool_return_message import LettaResponseToolReturnMessage
-from .letta_response_tool_return_message_status import LettaResponseToolReturnMessageStatus
-from .letta_response_usage_message import LettaResponseUsageMessage
-from .letta_response_usage_message_usage import LettaResponseUsageMessageUsage
-from .letta_response_user_message import LettaResponseUserMessage
+from .letta_response_messages_item import (
+    LettaResponseMessagesItem,
+    LettaResponseMessagesItem_AssistantMessage,
+    LettaResponseMessagesItem_ReasoningMessage,
+    LettaResponseMessagesItem_SystemMessage,
+    LettaResponseMessagesItem_ToolCallMessage,
+    LettaResponseMessagesItem_ToolReturnMessage,
+    LettaResponseMessagesItem_UserMessage,
+)
 from .letta_schemas_letta_message_tool_call import LettaSchemasLettaMessageToolCall
 from .letta_schemas_message_message import LettaSchemasMessageMessage
 from .letta_schemas_openai_chat_completion_request_tool import LettaSchemasOpenaiChatCompletionRequestTool
@@ -120,7 +115,6 @@ from .tool_message import ToolMessage
 from .tool_return_message import ToolReturnMessage
 from .tool_return_message_status import ToolReturnMessageStatus
 from .tool_rule_type import ToolRuleType
-from .usage_message import UsageMessage
 from .usage_statistics import UsageStatistics
 from .user import User
 from .user_create import UserCreate
@@ -135,6 +129,7 @@ __all__ = [
     "ActionModel",
     "ActionParametersModel",
     "ActionResponseModel",
+    "AgentEnvironmentVariable",
     "AgentState",
     "AgentStateToolRulesItem",
     "AgentType",
@@ -181,21 +176,13 @@ __all__ = [
     "JobStatus",
     "LettaRequest",
     "LettaResponse",
-    "LettaResponseAssistantMessage",
-    "LettaResponseLettaUsageStatistics",
-    "LettaResponseReasoningMessage",
-    "LettaResponseSystemMessage",
-    "LettaResponseToolCall",
-    "LettaResponseToolCallDelta",
-    "LettaResponseToolCallMessage",
-    "LettaResponseToolCallMessageToolCall",
-    "LettaResponseToolCallMessageToolCallOne",
-    "LettaResponseToolCallMessageToolCallZero",
-    "LettaResponseToolReturnMessage",
-    "LettaResponseToolReturnMessageStatus",
-    "LettaResponseUsageMessage",
-    "LettaResponseUsageMessageUsage",
-    "LettaResponseUserMessage",
+    "LettaResponseMessagesItem",
+    "LettaResponseMessagesItem_AssistantMessage",
+    "LettaResponseMessagesItem_ReasoningMessage",
+    "LettaResponseMessagesItem_SystemMessage",
+    "LettaResponseMessagesItem_ToolCallMessage",
+    "LettaResponseMessagesItem_ToolReturnMessage",
+    "LettaResponseMessagesItem_UserMessage",
     "LettaSchemasLettaMessageToolCall",
     "LettaSchemasMessageMessage",
     "LettaSchemasOpenaiChatCompletionRequestTool",
@@ -250,7 +237,6 @@ __all__ = [
     "ToolReturnMessage",
     "ToolReturnMessageStatus",
     "ToolRuleType",
-    "UsageMessage",
     "UsageStatistics",
     "User",
     "UserCreate",

letta/types/agent_environment_variable.py

@@ -0,0 +1,68 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import pydantic
+import datetime as dt
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class AgentEnvironmentVariable(UniversalBaseModel):
+    created_by_id: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The id of the user that made this object.
+    """
+
+    last_updated_by_id: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The id of the user that made this object.
+    """
+
+    created_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
+    """
+    The timestamp when the object was created.
+    """
+
+    updated_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
+    """
+    The timestamp when the object was last updated.
+    """
+
+    id: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The human-friendly ID of the Agent-env
+    """
+
+    key: str = pydantic.Field()
+    """
+    The name of the environment variable.
+    """
+
+    value: str = pydantic.Field()
+    """
+    The value of the environment variable.
+    """
+
+    description: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    An optional description of the environment variable.
+    """
+
+    organization_id: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The ID of the organization this environment variable belongs to.
+    """
+
+    agent_id: str = pydantic.Field()
+    """
+    The ID of the agent this environment variable belongs to.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

letta/types/agent_state.py

@@ -13,6 +13,7 @@ from ..core.serialization import FieldMetadata
 from .memory import Memory
 from .letta_schemas_tool_tool import LettaSchemasToolTool
 from .source import Source
+from .agent_environment_variable import AgentEnvironmentVariable
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 
 
@@ -21,15 +22,15 @@ class AgentState(UniversalBaseModel):
     Representation of an agent's state. This is the state of the agent at a given time, and is persisted in the DB backend. The state has all the information needed to recreate a persisted agent.
 
     Parameters:
-    id (str): The unique identifier of the agent.
-    name (str): The name of the agent (must be unique to the user).
-    created_at (datetime): The datetime the agent was created.
-    message_ids (List[str]): The ids of the messages in the agent's in-context memory.
-    memory (Memory): The in-context memory of the agent.
-    tools (List[str]): The tools used by the agent. This includes any memory editing functions specified in `memory`.
-    system (str): The system prompt used by the agent.
-    llm_config (LLMConfig): The LLM configuration used by the agent.
-    embedding_config (EmbeddingConfig): The embedding configuration used by the agent.
+        id (str): The unique identifier of the agent.
+        name (str): The name of the agent (must be unique to the user).
+        created_at (datetime): The datetime the agent was created.
+        message_ids (List[str]): The ids of the messages in the agent's in-context memory.
+        memory (Memory): The in-context memory of the agent.
+        tools (List[str]): The tools used by the agent. This includes any memory editing functions specified in `memory`.
+        system (str): The system prompt used by the agent.
+        llm_config (LLMConfig): The LLM configuration used by the agent.
+        embedding_config (EmbeddingConfig): The embedding configuration used by the agent.
     """
 
     created_by_id: typing.Optional[str] = pydantic.Field(default=None)
@@ -129,6 +130,11 @@ class AgentState(UniversalBaseModel):
     The tags associated with the agent.
     """
 
+    tool_exec_environment_variables: typing.List[AgentEnvironmentVariable] = pydantic.Field()
+    """
+    The environment variables for tool execution specific to this agent.
+    """
+
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
     else:

letta/types/assistant_message_output.py

@@ -2,15 +2,14 @@
 
 from ..core.pydantic_utilities import UniversalBaseModel
 import datetime as dt
-import typing
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
 import pydantic
 
 
 class AssistantMessageOutput(UniversalBaseModel):
     id: str
     date: dt.datetime
-    message_type: typing.Literal["assistant_message"] = "assistant_message"
     assistant_message: str
 
     if IS_PYDANTIC_V2:

letta/types/block.py

@@ -13,15 +13,15 @@ class Block(UniversalBaseModel):
     A Block represents a reserved section of the LLM's context window which is editable. `Block` objects contained in the `Memory` object, which is able to edit the Block values.
 
     Parameters:
-    label (str): The label of the block (e.g. 'human', 'persona'). This defines a category for the block.
-    value (str): The value of the block. This is the string that is represented in the context window.
-    limit (int): The character limit of the block.
-    is*template (bool): Whether the block is a template (e.g. saved human/persona options). Non-template blocks are not stored in the database and are ephemeral, while templated blocks are stored in the database.
-    label (str): The label of the block (e.g. 'human', 'persona'). This defines a category for the block.
-    template_name (str): The name of the block template (if it is a template).
-    description (str): Description of the block.
-    metadata* (Dict): Metadata of the block.
-    user_id (str): The unique identifier of the user associated with the block.
+        label (str): The label of the block (e.g. 'human', 'persona'). This defines a category for the block.
+        value (str): The value of the block. This is the string that is represented in the context window.
+        limit (int): The character limit of the block.
+        is_template (bool): Whether the block is a template (e.g. saved human/persona options). Non-template blocks are not stored in the database and are ephemeral, while templated blocks are stored in the database.
+        label (str): The label of the block (e.g. 'human', 'persona'). This defines a category for the block.
+        template_name (str): The name of the block template (if it is a template).
+        description (str): Description of the block.
+        metadata_ (Dict): Metadata of the block.
+        user_id (str): The unique identifier of the user associated with the block.
     """
 
     value: str = pydantic.Field()

letta/types/context_window_overview.py

@@ -43,6 +43,11 @@ class ContextWindowOverview(UniversalBaseModel):
     The number of tokens in the external memory summary (archival + recall metadata).
     """
 
+    external_memory_summary: str = pydantic.Field()
+    """
+    The metadata summary of the external memory sources (archival + recall metadata).
+    """
+
     num_tokens_system: int = pydantic.Field()
     """
     The number of tokens in the system prompt.

letta/types/embedding_config.py

@@ -12,14 +12,14 @@ class EmbeddingConfig(UniversalBaseModel):
     Embedding model configuration. This object specifies all the information necessary to access an embedding model to usage with Letta, except for secret keys.
 
     Attributes:
-    embedding_endpoint_type (str): The endpoint type for the model.
-    embedding_endpoint (str): The endpoint for the model.
-    embedding_model (str): The model for the embedding.
-    embedding_dim (int): The dimension of the embedding.
-    embedding_chunk_size (int): The chunk size of the embedding.
-    azure_endpoint (:obj:`str`, optional): The Azure endpoint for the model (Azure only).
-    azure_version (str): The Azure version for the model (Azure only).
-    azure_deployment (str): The Azure deployment for the model (Azure only).
+        embedding_endpoint_type (str): The endpoint type for the model.
+        embedding_endpoint (str): The endpoint for the model.
+        embedding_model (str): The model for the embedding.
+        embedding_dim (int): The dimension of the embedding.
+        embedding_chunk_size (int): The chunk size of the embedding.
+        azure_endpoint (:obj:`str`, optional): The Azure endpoint for the model (Azure only).
+        azure_version (str): The Azure version for the model (Azure only).
+        azure_deployment (str): The Azure deployment for the model (Azure only).
     """
 
     embedding_endpoint_type: EmbeddingConfigEmbeddingEndpointType = pydantic.Field()
@@ -47,6 +47,11 @@ class EmbeddingConfig(UniversalBaseModel):
     The chunk size of the embedding.
     """
 
+    handle: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The handle for this config, in the format provider/model-name.
+    """
+
     azure_endpoint: typing.Optional[str] = pydantic.Field(default=None)
     """
     The Azure endpoint for the model.

letta/types/internal_server_error_body.py

@@ -7,7 +7,7 @@ import pydantic
 
 
 class InternalServerErrorBody(UniversalBaseModel):
-    message: typing.Literal["Migration failed"] = "Migration failed"
+    message: typing.Literal["Failed to create agent template"] = "Failed to create agent template"
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

letta/types/job.py

@@ -15,11 +15,11 @@ class Job(UniversalBaseModel):
     Representation of offline jobs, used for tracking status of data loading tasks (involving parsing and embedding files).
 
     Parameters:
-    id (str): The unique identifier of the job.
-    status (JobStatus): The status of the job.
-    created_at (datetime): The unix timestamp of when the job was created.
-    completed_at (datetime): The unix timestamp of when the job was completed.
-    user_id (str): The unique identifier of the user associated with the.
+        id (str): The unique identifier of the job.
+        status (JobStatus): The status of the job.
+        created_at (datetime): The unix timestamp of when the job was created.
+        completed_at (datetime): The unix timestamp of when the job was completed.
+        user_id (str): The unique identifier of the user associated with the.
     """
 
     created_by_id: typing.Optional[str] = pydantic.Field(default=None)

letta/types/letta_response.py

@@ -1,118 +1,31 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ..core.pydantic_utilities import UniversalBaseModel
-import typing_extensions
 import typing
-from .letta_response_assistant_message import LettaResponseAssistantMessage
-from ..core.serialization import FieldMetadata
-from .letta_response_letta_usage_statistics import LettaResponseLettaUsageStatistics
+from .letta_response_messages_item import LettaResponseMessagesItem
 import pydantic
-from .letta_response_reasoning_message import LettaResponseReasoningMessage
-from .letta_response_system_message import LettaResponseSystemMessage
-from .letta_response_tool_call import LettaResponseToolCall
-from .letta_response_tool_call_delta import LettaResponseToolCallDelta
-from .letta_response_tool_call_message import LettaResponseToolCallMessage
-from .letta_response_tool_return_message import LettaResponseToolReturnMessage
-from .letta_response_usage_message import LettaResponseUsageMessage
-from .letta_response_user_message import LettaResponseUserMessage
+from .letta_usage_statistics import LettaUsageStatistics
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 
 
 class LettaResponse(UniversalBaseModel):
-    assistant_message: typing_extensions.Annotated[
-        typing.Optional[LettaResponseAssistantMessage], FieldMetadata(alias="AssistantMessage")
-    ] = None
-    letta_usage_statistics: typing_extensions.Annotated[
-        typing.Optional[LettaResponseLettaUsageStatistics], FieldMetadata(alias="LettaUsageStatistics")
-    ] = pydantic.Field(default=None)
-    """
-    Usage statistics for the agent interaction.
-    
-    Attributes:
-    completion_tokens (int): The number of tokens generated by the agent.
-    prompt_tokens (int): The number of tokens in the prompt.
-    total_tokens (int): The total number of tokens processed by the agent.
-    step_count (int): The number of steps taken by the agent.
     """
+    Response object from an agent interaction, consisting of the new messages generated by the agent and usage statistics.
+    The type of the returned messages can be either `Message` or `LettaMessage`, depending on what was specified in the request.
 
-    reasoning_message: typing_extensions.Annotated[
-        typing.Optional[LettaResponseReasoningMessage], FieldMetadata(alias="ReasoningMessage")
-    ] = pydantic.Field(default=None)
-    """
-    Representation of an agent's internal reasoning.
-    
     Attributes:
-    reasoning (str): The internal reasoning of the agent
-    id (str): The ID of the message
-    date (datetime): The date the message was created in ISO format
+        messages (List[Union[Message, LettaMessage]]): The messages returned by the agent.
+        usage (LettaUsageStatistics): The usage statistics
     """
 
-    system_message: typing_extensions.Annotated[
-        typing.Optional[LettaResponseSystemMessage], FieldMetadata(alias="SystemMessage")
-    ] = pydantic.Field(default=None)
+    messages: typing.List[LettaResponseMessagesItem] = pydantic.Field()
     """
-    A message generated by the system. Never streamed back on a response, only used for cursor pagination.
-    
-    Attributes:
-    message (str): The message sent by the system
-    id (str): The ID of the message
-    date (datetime): The date the message was created in ISO format
+    The messages returned by the agent.
     """
 
-    tool_call: typing_extensions.Annotated[typing.Optional[LettaResponseToolCall], FieldMetadata(alias="ToolCall")] = (
-        None
-    )
-    tool_call_delta: typing_extensions.Annotated[
-        typing.Optional[LettaResponseToolCallDelta], FieldMetadata(alias="ToolCallDelta")
-    ] = None
-    tool_call_message: typing_extensions.Annotated[
-        typing.Optional[LettaResponseToolCallMessage], FieldMetadata(alias="ToolCallMessage")
-    ] = pydantic.Field(default=None)
+    usage: LettaUsageStatistics = pydantic.Field()
     """
-    A message representing a request to call a tool (generated by the LLM to trigger tool execution).
-    
-    Attributes:
-    tool_call (Union[ToolCall, ToolCallDelta]): The tool call
-    id (str): The ID of the message
-    date (datetime): The date the message was created in ISO format
-    """
-
-    tool_return_message: typing_extensions.Annotated[
-        typing.Optional[LettaResponseToolReturnMessage], FieldMetadata(alias="ToolReturnMessage")
-    ] = pydantic.Field(default=None)
-    """
-    A message representing the return value of a tool call (generated by Letta executing the requested tool).
-    
-    Attributes:
-    tool_return (str): The return value of the tool
-    status (Literal["success", "error"]): The status of the tool call
-    id (str): The ID of the message
-    date (datetime): The date the message was created in ISO format
-    tool_call_id (str): A unique identifier for the tool call that generated this message
-    stdout (Optional[List(str)]): Captured stdout (e.g. prints, logs) from the tool invocation
-    stderr (Optional[List(str)]): Captured stderr from the tool invocation
-    """
-
-    usage_message: typing_extensions.Annotated[
-        typing.Optional[LettaResponseUsageMessage], FieldMetadata(alias="UsageMessage")
-    ] = pydantic.Field(default=None)
-    """
-    A message representint the usage statistics for the agent interaction.
-    
-    Attributes:
-    usage (LettaUsageStatistics): Usage statistics for the agent interaction.
-    """
-
-    user_message: typing_extensions.Annotated[
-        typing.Optional[LettaResponseUserMessage], FieldMetadata(alias="UserMessage")
-    ] = pydantic.Field(default=None)
-    """
-    A message sent by the user. Never streamed back on a response, only used for cursor pagination.
-    
-    Attributes:
-    message (str): The message sent by the user
-    id (str): The ID of the message
-    date (datetime): The date the message was created in ISO format
+    The usage statistics of the agent.
     """
 
     if IS_PYDANTIC_V2: