letta-nightly 0.13.0.dev20251031104146__py3-none-any.whl → 0.13.1.dev20251101010313__py3-none-any.whl

letta/cli/cli_load.py

@@ -1,16 +0,0 @@
-"""
-This file contains functions for loading data into Letta's archival storage.
-
-Data can be loaded with the following command, once a load function is defined:
-```
-letta load <data-connector-type> --name <dataset-name> [ADDITIONAL ARGS]
-```
-
-"""
-
-import typer
-
-app = typer.Typer()
-
-
-default_extensions = "txt,md,pdf"

letta/client/streaming.py

@@ -1,95 +0,0 @@
-import json
-from typing import Generator, Union, get_args
-
-import httpx
-from httpx_sse import SSEError, connect_sse
-from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
-
-from letta.constants import OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING
-from letta.errors import LLMError
-from letta.log import get_logger
-from letta.schemas.enums import MessageStreamStatus
-from letta.schemas.letta_message import AssistantMessage, HiddenReasoningMessage, ReasoningMessage, ToolCallMessage, ToolReturnMessage
-from letta.schemas.letta_response import LettaStreamingResponse
-from letta.schemas.usage import LettaUsageStatistics
-
-logger = get_logger(__name__)
-
-
-def _sse_post(url: str, data: dict, headers: dict) -> Generator[Union[LettaStreamingResponse, ChatCompletionChunk], None, None]:
-    """
-    Sends an SSE POST request and yields parsed response chunks.
-    """
-    # TODO: Please note his is a very generous timeout for e2b reasons
-    with httpx.Client(timeout=httpx.Timeout(5 * 60.0, read=5 * 60.0)) as client:
-        with connect_sse(client, method="POST", url=url, json=data, headers=headers) as event_source:
-            # Check for immediate HTTP errors before processing the SSE stream
-            if not event_source.response.is_success:
-                response_bytes = event_source.response.read()
-                logger.warning(f"SSE request error: {vars(event_source.response)}")
-                logger.warning(response_bytes.decode("utf-8"))
-
-                try:
-                    response_dict = json.loads(response_bytes.decode("utf-8"))
-                    error_message = response_dict.get("error", {}).get("message", "")
-
-                    if OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING in error_message:
-                        logger.error(error_message)
-                        raise LLMError(error_message)
-                except LLMError:
-                    raise
-                except Exception:
-                    logger.error("Failed to parse SSE message, raising HTTP error")
-                    event_source.response.raise_for_status()
-
-            try:
-                for sse in event_source.iter_sse():
-                    if sse.data in {status.value for status in MessageStreamStatus}:
-                        yield MessageStreamStatus(sse.data)
-                        if sse.data == MessageStreamStatus.done.value:
-                            # We received the [DONE], so stop reading the stream.
-                            break
-                    else:
-                        chunk_data = json.loads(sse.data)
-
-                        if "reasoning" in chunk_data:
-                            yield ReasoningMessage(**chunk_data)
-                        elif chunk_data.get("message_type") == "assistant_message":
-                            yield AssistantMessage(**chunk_data)
-                        elif "hidden_reasoning" in chunk_data:
-                            yield HiddenReasoningMessage(**chunk_data)
-                        elif "tool_call" in chunk_data:
-                            yield ToolCallMessage(**chunk_data)
-                        elif "tool_return" in chunk_data:
-                            yield ToolReturnMessage(**chunk_data)
-                        elif "step_count" in chunk_data:
-                            yield LettaUsageStatistics(**chunk_data)
-                        elif chunk_data.get("object") == get_args(ChatCompletionChunk.__annotations__["object"])[0]:
-                            yield ChatCompletionChunk(**chunk_data)
-                        else:
-                            raise ValueError(f"Unknown message type in chunk_data: {chunk_data}")
-
-            except SSEError as e:
-                logger.error(f"SSE stream error: {e}")
-
-                if "application/json" in str(e):
-                    response = client.post(url=url, json=data, headers=headers)
-
-                    if response.headers.get("Content-Type", "").startswith("application/json"):
-                        error_details = response.json()
-                        logger.error(f"POST Error: {error_details}")
-                    else:
-                        logger.error("Failed to retrieve JSON error message via retry.")
-
-                raise e
-
-            except Exception as e:
-                logger.error(f"Unexpected exception: {e}")
-
-                if event_source.response.request:
-                    logger.error(f"HTTP Request: {vars(event_source.response.request)}")
-                if event_source.response:
-                    logger.error(f"HTTP Status: {event_source.response.status_code}")
-                    logger.error(f"HTTP Headers: {event_source.response.headers}")
-
-                raise e

letta/client/utils.py

@@ -1,78 +0,0 @@
-import re
-from datetime import datetime
-from typing import Optional
-
-from IPython.display import HTML, display
-from sqlalchemy.testing.plugin.plugin_base import warnings
-
-from letta.local_llm.constants import ASSISTANT_MESSAGE_CLI_SYMBOL, INNER_THOUGHTS_CLI_SYMBOL
-
-
-def pprint(messages):
-    """Utility function for pretty-printing the output of client.send_message in notebooks"""
-
-    css_styles = """
-    <style>
-        .terminal {
-            background-color: #002b36;
-            color: #839496;
-            font-family: 'Courier New', Courier, monospace;
-            padding: 10px;
-            border-radius: 5px;
-        }
-        .terminal strong {
-            color: #b58900;
-        }
-        .terminal .function-return {
-            color: #2aa198;
-        }
-        .terminal .internal-monologue {
-            color: #d33682;
-        }
-        .terminal .function-call {
-            color: #2aa198;
-        }
-        .terminal .assistant-message {
-            color: #859900;
-        }
-        .terminal pre {
-            color: #839496;
-        }
-    </style>
-    """
-
-    html_content = css_styles + "<div class='terminal'>"
-    for message in messages:
-        date_str = message["date"]
-        date_formatted = datetime.fromisoformat(date_str.replace("Z", "+00:00")).strftime("%Y-%m-%d %H:%M:%S")
-
-        if "function_return" in message:
-            return_string = message["function_return"]
-            return_status = message["status"]
-            html_content += f"<p><strong>🛠️ [{date_formatted}] Function Return ({return_status}):</strong></p>"
-            html_content += f"<p class='function-return'>{return_string}</p>"
-        elif "internal_monologue" in message:
-            html_content += f"<p><strong>{INNER_THOUGHTS_CLI_SYMBOL} [{date_formatted}] Internal Monologue:</strong></p>"
-            html_content += f"<p class='internal-monologue'>{message['internal_monologue']}</p>"
-        elif "function_call" in message:
-            html_content += f"<p><strong>🛠️ [[{date_formatted}] Function Call:</strong></p>"
-            html_content += f"<p class='function-call'>{message['function_call']}</p>"
-        elif "assistant_message" in message:
-            html_content += f"<p><strong>{ASSISTANT_MESSAGE_CLI_SYMBOL} [{date_formatted}] Assistant Message:</strong></p>"
-            html_content += f"<p class='assistant-message'>{message['assistant_message']}</p>"
-        html_content += "<br>"
-    html_content += "</div>"
-
-    display(HTML(html_content))
-
-
-def derive_function_name_regex(function_string: str) -> Optional[str]:
-    # Regular expression to match the function name
-    match = re.search(r"def\s+([a-zA-Z_]\w*)\s*\(", function_string)
-
-    if match:
-        function_name = match.group(1)
-        return function_name
-    else:
-        warnings.warn("No function name found.")
-        return None

letta/functions/async_composio_toolset.py

@@ -1,109 +0,0 @@
-import json
-from typing import Any
-
-import aiohttp
-from composio import ComposioToolSet as BaseComposioToolSet
-from composio.exceptions import (
-    ApiKeyNotProvidedError,
-    ComposioSDKError,
-    ConnectedAccountNotFoundError,
-    EnumMetadataNotFound,
-    EnumStringNotFound,
-)
-
-
-class AsyncComposioToolSet(BaseComposioToolSet, runtime="letta", description_char_limit=1024):
-    """
-    Async version of ComposioToolSet client for interacting with Composio API
-    Used to asynchronously hit the execute action endpoint
-
-    https://docs.composio.dev/api-reference/api-reference/v3/tools/post-api-v-3-tools-execute-action
-    """
-
-    def __init__(self, api_key: str, entity_id: str, lock: bool = True):
-        """
-        Initialize the AsyncComposioToolSet client
-
-        Args:
-            api_key (str): Your Composio API key
-            entity_id (str): Your Composio entity ID
-            lock (bool): Whether to use locking (default: True)
-        """
-        super().__init__(api_key=api_key, entity_id=entity_id, lock=lock)
-
-        self.headers = {
-            "Content-Type": "application/json",
-            "X-API-Key": self._api_key,
-        }
-
-    async def execute_action(
-        self,
-        action: str,
-        params: dict[str, Any] = {},
-    ) -> dict[str, Any]:
-        """
-        Execute an action asynchronously using the Composio API
-
-        Args:
-            action (str): The name of the action to execute
-            params (dict[str, Any], optional): Parameters for the action
-
-        Returns:
-            dict[str, Any]: The API response
-
-        Raises:
-            ApiKeyNotProvidedError: if the API key is not provided
-            ComposioSDKError: if a general Composio SDK error occurs
-            ConnectedAccountNotFoundError: if the connected account is not found
-            EnumMetadataNotFound: if enum metadata is not found
-            EnumStringNotFound: if enum string is not found
-            aiohttp.ClientError: if a network-related error occurs
-            ValueError: if an error with the parameters or response occurs
-        """
-        API_VERSION = "v3"
-        endpoint = f"{self._base_url}/{API_VERSION}/tools/execute/{action}"
-
-        json_payload = {
-            "entity_id": self.entity_id,
-            "arguments": params or {},
-        }
-
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(endpoint, headers=self.headers, json=json_payload) as response:
-                    print(response, response.status, response.reason, response.content)
-                    if response.status == 200:
-                        return await response.json()
-                    else:
-                        error_text = await response.text()
-                        try:
-                            error_json = json.loads(error_text)
-                            error_message = error_json.get("message", error_text)
-                            error_code = error_json.get("code")
-
-                            # Handle specific error codes from Composio API
-                            if error_code == 10401 or "API_KEY_NOT_FOUND" in error_message:
-                                raise ApiKeyNotProvidedError()
-                            if (
-                                "connected account not found" in error_message.lower()
-                                or "no connected account found" in error_message.lower()
-                            ):
-                                raise ConnectedAccountNotFoundError(f"Connected account not found: {error_message}")
-                            if "enum metadata not found" in error_message.lower():
-                                raise EnumMetadataNotFound(f"Enum metadata not found: {error_message}")
-                            if "enum string not found" in error_message.lower():
-                                raise EnumStringNotFound(f"Enum string not found: {error_message}")
-                        except json.JSONDecodeError:
-                            error_message = error_text
-
-                        # If no specific error was identified, raise a general error
-                        raise ValueError(f"API request failed with status {response.status}: {error_message}")
-        except aiohttp.ClientError as e:
-            # Wrap network errors in ComposioSDKError
-            raise ComposioSDKError(f"Network error when calling Composio API: {str(e)}")
-        except ValueError:
-            # Re-raise ValueError (which could be our custom error message or a JSON parsing error)
-            raise
-        except Exception as e:
-            # Catch any other exceptions and wrap them in ComposioSDKError
-            raise ComposioSDKError(f"Unexpected error when calling Composio API: {str(e)}")

letta/functions/composio_helpers.py

@@ -1,96 +0,0 @@
-import os
-from typing import Any, Optional
-
-from composio.constants import DEFAULT_ENTITY_ID
-from composio.exceptions import (
-    ApiKeyNotProvidedError,
-    ComposioSDKError,
-    ConnectedAccountNotFoundError,
-    EnumMetadataNotFound,
-    EnumStringNotFound,
-)
-
-from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY
-from letta.functions.async_composio_toolset import AsyncComposioToolSet
-from letta.utils import run_async_task
-
-
-# TODO: This is kind of hacky, as this is used to search up the action later on composio's side
-# TODO: So be very careful changing/removing these pair of functions
-def _generate_func_name_from_composio_action(action_name: str) -> str:
-    """
-    Generates the composio function name from the composio action.
-
-    Args:
-        action_name: The composio action name
-
-    Returns:
-        function name
-    """
-    return action_name.lower()
-
-
-def generate_composio_action_from_func_name(func_name: str) -> str:
-    """
-    Generates the composio action from the composio function name.
-
-    Args:
-        func_name: The composio function name
-
-    Returns:
-        composio action name
-    """
-    return func_name.upper()
-
-
-def generate_composio_tool_wrapper(action_name: str) -> tuple[str, str]:
-    # Generate func name
-    func_name = _generate_func_name_from_composio_action(action_name)
-
-    wrapper_function_str = f"""\
-def {func_name}(**kwargs):
-    raise RuntimeError("Something went wrong - we should never be using the persisted source code for Composio. Please reach out to Letta team")
-"""
-
-    # Compile safety check
-    _assert_code_gen_compilable(wrapper_function_str.strip())
-
-    return func_name, wrapper_function_str.strip()
-
-
-async def execute_composio_action_async(
-    action_name: str, args: dict, api_key: Optional[str] = None, entity_id: Optional[str] = None
-) -> tuple[str, str]:
-    entity_id = entity_id or os.getenv(COMPOSIO_ENTITY_ENV_VAR_KEY, DEFAULT_ENTITY_ID)
-    composio_toolset = AsyncComposioToolSet(api_key=api_key, entity_id=entity_id, lock=False)
-    try:
-        response = await composio_toolset.execute_action(action=action_name, params=args)
-    except ApiKeyNotProvidedError as e:
-        raise RuntimeError(f"API key not provided or invalid for Composio action '{action_name}': {str(e)}")
-    except ConnectedAccountNotFoundError as e:
-        raise RuntimeError(f"Connected account not found for Composio action '{action_name}': {str(e)}")
-    except EnumMetadataNotFound as e:
-        raise RuntimeError(f"Enum metadata not found for Composio action '{action_name}': {str(e)}")
-    except EnumStringNotFound as e:
-        raise RuntimeError(f"Enum string not found for Composio action '{action_name}': {str(e)}")
-    except ComposioSDKError as e:
-        raise RuntimeError(f"Composio SDK error while executing action '{action_name}': {str(e)}")
-    except Exception as e:
-        print(type(e))
-        raise RuntimeError(f"An unexpected error occurred in Composio SDK while executing action '{action_name}': {str(e)}")
-
-    if "error" in response and response["error"]:
-        raise RuntimeError(f"Error while executing action '{action_name}': {str(response['error'])}")
-
-    return response.get("data")
-
-
-def execute_composio_action(action_name: str, args: dict, api_key: Optional[str] = None, entity_id: Optional[str] = None) -> Any:
-    return run_async_task(execute_composio_action_async(action_name, args, api_key, entity_id))
-
-
-def _assert_code_gen_compilable(code_str):
-    try:
-        compile(code_str, "<string>", "exec")
-    except SyntaxError as e:
-        print(f"Syntax error in code: {e}")

letta/helpers/composio_helpers.py

@@ -1,38 +0,0 @@
-from logging import Logger
-from typing import Optional
-
-from letta.schemas.user import User
-from letta.services.sandbox_config_manager import SandboxConfigManager
-from letta.settings import tool_settings
-
-
-def get_composio_api_key(actor: User, logger: Optional[Logger] = None) -> Optional[str]:
-    api_keys = SandboxConfigManager().list_sandbox_env_vars_by_key(key="COMPOSIO_API_KEY", actor=actor)
-    if not api_keys:
-        if logger:
-            logger.debug("No API keys found for Composio. Defaulting to the environment variable...")
-        if tool_settings.composio_api_key:
-            return tool_settings.composio_api_key
-        else:
-            return None
-    else:
-        # TODO: Add more protections around this
-        # Ideally, not tied to a specific sandbox, but for now we just get the first one
-        # Theoretically possible for someone to have different composio api keys per sandbox
-        return api_keys[0].value
-
-
-async def get_composio_api_key_async(actor: User, logger: Optional[Logger] = None) -> Optional[str]:
-    api_keys = await SandboxConfigManager().list_sandbox_env_vars_by_key_async(key="COMPOSIO_API_KEY", actor=actor)
-    if not api_keys:
-        if logger:
-            logger.debug("No API keys found for Composio. Defaulting to the environment variable...")
-        if tool_settings.composio_api_key:
-            return tool_settings.composio_api_key
-        else:
-            return None
-    else:
-        # TODO: Add more protections around this
-        # Ideally, not tied to a specific sandbox, but for now we just get the first one
-        # Theoretically possible for someone to have different composio api keys per sandbox
-        return api_keys[0].value

letta/orm/job_messages.py

@@ -1,33 +0,0 @@
-from typing import TYPE_CHECKING
-
-from sqlalchemy import ForeignKey, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-
-from letta.orm.sqlalchemy_base import SqlalchemyBase
-
-if TYPE_CHECKING:
-    from letta.orm.job import Job
-    from letta.orm.message import Message
-
-
-class JobMessage(SqlalchemyBase):
-    """Tracks messages that were created during job execution."""
-
-    __tablename__ = "job_messages"
-    __table_args__ = (UniqueConstraint("job_id", "message_id", name="unique_job_message"),)
-
-    id: Mapped[int] = mapped_column(primary_key=True, doc="Unique identifier for the job message")
-    job_id: Mapped[str] = mapped_column(
-        ForeignKey("jobs.id", ondelete="CASCADE"),
-        nullable=False,  # A job message must belong to a job
-        doc="ID of the job that created the message",
-    )
-    message_id: Mapped[str] = mapped_column(
-        ForeignKey("messages.id", ondelete="CASCADE"),
-        nullable=False,  # A job message must have a message
-        doc="ID of the message created by the job",
-    )
-
-    # Relationships
-    job: Mapped["Job"] = relationship("Job", back_populates="job_messages")
-    message: Mapped["Message"] = relationship("Message", back_populates="job_message")