letta-nightly 0.7.7.dev20250430205840__py3-none-any.whl → 0.7.8.dev20250501104226__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.7"
+__version__ = "0.7.8"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -21,14 +21,14 @@ from letta.constants import (
 )
 from letta.errors import ContextWindowExceededError
 from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_function_annotations_from_source
+from letta.functions.composio_helpers import execute_composio_action, generate_composio_action_from_func_name
 from letta.functions.functions import get_function_from_module
-from letta.functions.helpers import execute_composio_action, generate_composio_action_from_func_name
 from letta.functions.mcp_client.base_client import BaseMCPClient
 from letta.helpers import ToolRulesSolver
 from letta.helpers.composio_helpers import get_composio_api_key
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.json_helpers import json_dumps, json_loads
-from letta.helpers.message_helper import prepare_input_message_create
+from letta.helpers.message_helper import convert_message_creates_to_messages
 from letta.interface import AgentInterface
 from letta.llm_api.helpers import calculate_summarizer_cutoff, get_token_counts_for_messages, is_context_overflow_error
 from letta.llm_api.llm_api_tools import create
@@ -331,8 +331,10 @@ class Agent(BaseAgent):
                 log_telemetry(self.logger, "_get_ai_reply create start")
                 # New LLM client flow
                 llm_client = LLMClient.create(
-                    provider=self.agent_state.llm_config.model_endpoint_type,
+                    provider_name=self.agent_state.llm_config.provider_name,
+                    provider_type=self.agent_state.llm_config.model_endpoint_type,
                     put_inner_thoughts_first=put_inner_thoughts_first,
+                    actor_id=self.user.id,
                 )
 
                 if llm_client and not stream:
@@ -726,8 +728,7 @@ class Agent(BaseAgent):
         self.tool_rules_solver.clear_tool_history()
 
         # Convert MessageCreate objects to Message objects
-        message_objects = [prepare_input_message_create(m, self.agent_state.id, True, True) for m in input_messages]
-        next_input_messages = message_objects
+        next_input_messages = convert_message_creates_to_messages(input_messages, self.agent_state.id)
         counter = 0
         total_usage = UsageStatistics()
         step_count = 0
@@ -942,12 +943,7 @@ class Agent(BaseAgent):
                 model_endpoint=self.agent_state.llm_config.model_endpoint,
                 context_window_limit=self.agent_state.llm_config.context_window,
                 usage=response.usage,
-                # TODO(@caren): Add full provider support - this line is a workaround for v0 BYOK feature
-                provider_id=(
-                    self.provider_manager.get_anthropic_override_provider_id()
-                    if self.agent_state.llm_config.model_endpoint_type == "anthropic"
-                    else None
-                ),
+                provider_id=self.provider_manager.get_provider_id_from_name(self.agent_state.llm_config.provider_name),
                 job_id=job_id,
             )
             for message in all_new_messages:
@@ -1103,7 +1099,7 @@ class Agent(BaseAgent):
         logger.info(f"Packaged into message: {summary_message}")
 
         prior_len = len(in_context_messages_openai)
-        self.agent_state = self.agent_manager.trim_all_in_context_messages_except_system(agent_id=self.agent_state.id, actor=self.user)
+        self.agent_state = self.agent_manager.trim_older_in_context_messages(num=cutoff, agent_id=self.agent_state.id, actor=self.user)
         packed_summary_message = {"role": "user", "content": summary_message}
         # Prepend the summary
         self.agent_state = self.agent_manager.prepend_to_in_context_messages(

letta/agents/exceptions.py

@@ -0,0 +1,6 @@
+class IncompatibleAgentType(ValueError):
+    def __init__(self, expected_type: str, actual_type: str):
+        message = f"Incompatible agent type: expected '{expected_type}', but got '{actual_type}'."
+        super().__init__(message)
+        self.expected_type = expected_type
+        self.actual_type = actual_type

letta/agents/letta_agent.py

@@ -67,8 +67,10 @@ class LettaAgent(BaseAgent):
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
         llm_client = LLMClient.create(
-            provider=agent_state.llm_config.model_endpoint_type,
+            provider_name=agent_state.llm_config.provider_name,
+            provider_type=agent_state.llm_config.model_endpoint_type,
             put_inner_thoughts_first=True,
+            actor_id=self.actor.id,
         )
         for step in range(max_steps):
             response = await self._get_ai_reply(
@@ -109,8 +111,10 @@ class LettaAgent(BaseAgent):
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
         llm_client = LLMClient.create(
-            llm_config=agent_state.llm_config,
+            provider_name=agent_state.llm_config.provider_name,
+            provider_type=agent_state.llm_config.model_endpoint_type,
             put_inner_thoughts_first=True,
+            actor_id=self.actor.id,
         )
 
         for step in range(max_steps):
@@ -125,7 +129,7 @@ class LettaAgent(BaseAgent):
             # TODO: THIS IS INCREDIBLY UGLY
             # TODO: THERE ARE MULTIPLE COPIES OF THE LLM_CONFIG EVERYWHERE THAT ARE GETTING MANIPULATED
             interface = AnthropicStreamingInterface(
-                use_assistant_message=use_assistant_message, put_inner_thoughts_in_kwarg=llm_client.llm_config.put_inner_thoughts_in_kwargs
+                use_assistant_message=use_assistant_message, put_inner_thoughts_in_kwarg=agent_state.llm_config.put_inner_thoughts_in_kwargs
             )
             async for chunk in interface.process(stream):
                 yield f"data: {chunk.model_dump_json()}\n\n"
@@ -179,6 +183,7 @@ class LettaAgent(BaseAgent):
                 ToolType.LETTA_SLEEPTIME_CORE,
             }
             or (t.tool_type == ToolType.LETTA_MULTI_AGENT_CORE and t.name == "send_message_to_agents_matching_tags")
+            or (t.tool_type == ToolType.EXTERNAL_COMPOSIO)
         ]
 
         valid_tool_names = tool_rules_solver.get_allowed_tool_names(available_tools=set([t.name for t in tools]))
@@ -274,45 +279,49 @@ class LettaAgent(BaseAgent):
         return persisted_messages, continue_stepping
 
     def _rebuild_memory(self, in_context_messages: List[Message], agent_state: AgentState) -> List[Message]:
-        self.agent_manager.refresh_memory(agent_state=agent_state, actor=self.actor)
-
-        # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
-        curr_system_message = in_context_messages[0]
-        curr_memory_str = agent_state.memory.compile()
-        curr_system_message_text = curr_system_message.content[0].text
-        if curr_memory_str in curr_system_message_text:
-            # NOTE: could this cause issues if a block is removed? (substring match would still work)
-            logger.debug(
-                f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
-            )
-            return in_context_messages
+        try:
+            self.agent_manager.refresh_memory(agent_state=agent_state, actor=self.actor)
+
+            # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
+            curr_system_message = in_context_messages[0]
+            curr_memory_str = agent_state.memory.compile()
+            curr_system_message_text = curr_system_message.content[0].text
+            if curr_memory_str in curr_system_message_text:
+                # NOTE: could this cause issues if a block is removed? (substring match would still work)
+                logger.debug(
+                    f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
+                )
+                return in_context_messages
 
-        memory_edit_timestamp = get_utc_time()
+            memory_edit_timestamp = get_utc_time()
 
-        num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
-        num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
+            num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
+            num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
 
-        new_system_message_str = compile_system_message(
-            system_prompt=agent_state.system,
-            in_context_memory=agent_state.memory,
-            in_context_memory_last_edit=memory_edit_timestamp,
-            previous_message_count=num_messages,
-            archival_memory_size=num_archival_memories,
-        )
+            new_system_message_str = compile_system_message(
+                system_prompt=agent_state.system,
+                in_context_memory=agent_state.memory,
+                in_context_memory_last_edit=memory_edit_timestamp,
+                previous_message_count=num_messages,
+                archival_memory_size=num_archival_memories,
+            )
 
-        diff = united_diff(curr_system_message_text, new_system_message_str)
-        if len(diff) > 0:
-            logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
+            diff = united_diff(curr_system_message_text, new_system_message_str)
+            if len(diff) > 0:
+                logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
 
-            new_system_message = self.message_manager.update_message_by_id(
-                curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
-            )
+                new_system_message = self.message_manager.update_message_by_id(
+                    curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
+                )
 
-            # Skip pulling down the agent's memory again to save on a db call
-            return [new_system_message] + in_context_messages[1:]
+                # Skip pulling down the agent's memory again to save on a db call
+                return [new_system_message] + in_context_messages[1:]
 
-        else:
-            return in_context_messages
+            else:
+                return in_context_messages
+        except:
+            logger.exception(f"Failed to rebuild memory for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name})")
+            raise
 
     @trace_method
     async def _execute_tool(self, tool_name: str, tool_args: dict, agent_state: AgentState) -> Tuple[str, bool]:
@@ -331,6 +340,10 @@ class LettaAgent(BaseAgent):
                 results = await self._send_message_to_agents_matching_tags(**tool_args)
                 log_event(name="finish_send_message_to_agents_matching_tags", attributes=tool_args)
                 return json.dumps(results), True
+            elif target_tool.type == ToolType.EXTERNAL_COMPOSIO:
+                log_event(name=f"start_composio_{tool_name}_execution", attributes=tool_args)
+                log_event(name=f"finish_compsio_{tool_name}_execution", attributes=tool_args)
+                return tool_execution_result.func_return, True
             else:
                 tool_execution_manager = ToolExecutionManager(agent_state=agent_state, actor=self.actor)
                 # TODO: Integrate sandbox result

letta/agents/letta_agent_batch.py

@@ -156,8 +156,10 @@ class LettaAgentBatch:
 
         log_event(name="init_llm_client")
         llm_client = LLMClient.create(
-            provider=agent_states[0].llm_config.model_endpoint_type,
+            provider_name=agent_states[0].llm_config.provider_name,
+            provider_type=agent_states[0].llm_config.model_endpoint_type,
             put_inner_thoughts_first=True,
+            actor_id=self.actor.id,
         )
         agent_llm_config_mapping = {s.id: s.llm_config for s in agent_states}
 
@@ -273,8 +275,10 @@ class LettaAgentBatch:
 
             # translate provider‑specific response → OpenAI‑style tool call (unchanged)
             llm_client = LLMClient.create(
-                provider=item.llm_config.model_endpoint_type,
+                provider_name=item.llm_config.provider_name,
+                provider_type=item.llm_config.model_endpoint_type,
                 put_inner_thoughts_first=True,
+                actor_id=self.actor.id,
             )
             tool_call = (
                 llm_client.convert_response_to_chat_completion(

letta/agents/voice_agent.py

@@ -6,6 +6,7 @@ from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple
 import openai
 
 from letta.agents.base_agent import BaseAgent
+from letta.agents.exceptions import IncompatibleAgentType
 from letta.agents.voice_sleeptime_agent import VoiceSleeptimeAgent
 from letta.constants import NON_USER_MSG_PREFIX
 from letta.helpers.datetime_helpers import get_utc_time
@@ -18,7 +19,7 @@ from letta.helpers.tool_execution_helper import (
 from letta.interfaces.openai_chat_completions_streaming_interface import OpenAIChatCompletionsStreamingInterface
 from letta.log import get_logger
 from letta.orm.enums import ToolType
-from letta.schemas.agent import AgentState
+from letta.schemas.agent import AgentState, AgentType
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
@@ -68,8 +69,6 @@ class VoiceAgent(BaseAgent):
         block_manager: BlockManager,
         passage_manager: PassageManager,
         actor: User,
-        message_buffer_limit: int,
-        message_buffer_min: int,
     ):
         super().__init__(
             agent_id=agent_id, openai_client=openai_client, message_manager=message_manager, agent_manager=agent_manager, actor=actor
@@ -80,8 +79,6 @@ class VoiceAgent(BaseAgent):
         self.passage_manager = passage_manager
         # TODO: This is not guaranteed to exist!
         self.summary_block_label = "human"
-        self.message_buffer_limit = message_buffer_limit
-        self.message_buffer_min = message_buffer_min
 
         # Cached archival memory/message size
         self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_id)
@@ -108,8 +105,8 @@ class VoiceAgent(BaseAgent):
                 target_block_label=self.summary_block_label,
                 message_transcripts=[],
             ),
-            message_buffer_limit=self.message_buffer_limit,
-            message_buffer_min=self.message_buffer_min,
+            message_buffer_limit=agent_state.multi_agent_group.max_message_buffer_length,
+            message_buffer_min=agent_state.multi_agent_group.min_message_buffer_length,
         )
 
         return summarizer
@@ -124,9 +121,15 @@ class VoiceAgent(BaseAgent):
         """
         if len(input_messages) != 1 or input_messages[0].role != MessageRole.user:
             raise ValueError(f"Voice Agent was invoked with multiple input messages or message did not have role `user`: {input_messages}")
+
         user_query = input_messages[0].content[0].text
 
         agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
+
+        # Safety check
+        if agent_state.agent_type != AgentType.voice_convo_agent:
+            raise IncompatibleAgentType(expected_type=AgentType.voice_convo_agent, actual_type=agent_state.agent_type)
+
         summarizer = self.init_summarizer(agent_state=agent_state)
 
         in_context_messages = self.message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=self.actor)

letta/constants.py

@@ -4,7 +4,7 @@ from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
 LETTA_TOOL_EXECUTION_DIR = os.path.join(LETTA_DIR, "tool_execution_dir")
 
-LETTA_MODEL_ENDPOINT = "https://inference.memgpt.ai"
+LETTA_MODEL_ENDPOINT = "https://inference.letta.com"
 
 ADMIN_PREFIX = "/v1/admin"
 API_PREFIX = "/v1"
@@ -35,6 +35,10 @@ TOOL_CALL_ID_MAX_LEN = 29
 # minimum context window size
 MIN_CONTEXT_WINDOW = 4096
 
+# Voice Sleeptime message buffer lengths
+DEFAULT_MAX_MESSAGE_BUFFER_LENGTH = 30
+DEFAULT_MIN_MESSAGE_BUFFER_LENGTH = 15
+
 # embeddings
 MAX_EMBEDDING_DIM = 4096  # maximum supported embeding size - do NOT change or else DBs will need to be reset
 DEFAULT_EMBEDDING_CHUNK_SIZE = 300

letta/functions/composio_helpers.py

@@ -0,0 +1,100 @@
+import asyncio
+import os
+from typing import Any, Optional
+
+from composio import ComposioToolSet
+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
+
+
+# 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]:
+    try:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, execute_composio_action, action_name, args, api_key, entity_id)
+    except Exception as e:
+        raise RuntimeError(f"Error in execute_composio_action_async: {e}") from e
+
+
+def execute_composio_action(action_name: str, args: dict, api_key: Optional[str] = None, entity_id: Optional[str] = None) -> Any:
+    entity_id = entity_id or os.getenv(COMPOSIO_ENTITY_ENV_VAR_KEY, DEFAULT_ENTITY_ID)
+    try:
+        composio_toolset = ComposioToolSet(api_key=api_key, entity_id=entity_id, lock=False)
+        response = composio_toolset.execute_action(action=action_name, params=args)
+    except ApiKeyNotProvidedError:
+        raise RuntimeError(
+            f"Composio API key is missing for action '{action_name}'. "
+            "Please set the sandbox environment variables either through the ADE or the API."
+        )
+    except ConnectedAccountNotFoundError:
+        raise RuntimeError(f"No connected account was found for action '{action_name}'. " "Please link an account and try again.")
+    except EnumStringNotFound as e:
+        raise RuntimeError(f"Invalid value provided for action '{action_name}': " + str(e) + ". Please check the action parameters.")
+    except EnumMetadataNotFound as e:
+        raise RuntimeError(f"Invalid value provided for action '{action_name}': " + str(e) + ". Please check the action parameters.")
+    except ComposioSDKError as 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 _assert_code_gen_compilable(code_str):
+    try:
+        compile(code_str, "<string>", "exec")
+    except SyntaxError as e:
+        print(f"Syntax error in code: {e}")

letta/functions/functions.py

@@ -1,8 +1,9 @@
 import importlib
 import inspect
+from collections.abc import Callable
 from textwrap import dedent  # remove indentation
 from types import ModuleType
-from typing import Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
 
 from letta.errors import LettaToolCreateError
 from letta.functions.schema_generator import generate_schema
@@ -66,7 +67,8 @@ def parse_source_code(func) -> str:
     return source_code
 
 
-def get_function_from_module(module_name: str, function_name: str):
+# TODO (cliandy) refactor below two funcs
+def get_function_from_module(module_name: str, function_name: str) -> Callable[..., Any]:
     """
     Dynamically imports a function from a specified module.