letta-nightly 0.6.20.dev20250204104033__py3-none-any.whl → 0.6.21.dev20250205051348__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.20"
+__version__ = "0.6.21"
 
 
 # import clients

letta/agent.py

@@ -38,6 +38,7 @@ from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
 from letta.schemas.openai.chat_completion_response import Message as ChatCompletionMessage
 from letta.schemas.openai.chat_completion_response import UsageStatistics
+from letta.schemas.sandbox_config import SandboxRunResult
 from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
@@ -198,7 +199,9 @@ class Agent(BaseAgent):
             return True
         return False
 
-    def execute_tool_and_persist_state(self, function_name: str, function_args: dict, target_letta_tool: Tool):
+    def execute_tool_and_persist_state(
+        self, function_name: str, function_args: dict, target_letta_tool: Tool
+    ) -> tuple[str, Optional[SandboxRunResult]]:
         """
         Execute tool modifications and persist the state of the agent.
         Note: only some agent state modifications will be persisted, such as data in the AgentState ORM and block data
@@ -242,6 +245,7 @@ class Agent(BaseAgent):
                 assert orig_memory_str == self.agent_state.memory.compile(), "Memory should not be modified in a sandbox tool"
                 if updated_agent_state is not None:
                     self.update_memory_if_changed(updated_agent_state.memory)
+                return function_response, sandbox_run_result
         except Exception as e:
             # Need to catch error here, or else trunction wont happen
             # TODO: modify to function execution error
@@ -249,7 +253,44 @@ class Agent(BaseAgent):
                 function_name=function_name, exception_name=type(e).__name__, exception_message=str(e)
             )
 
-        return function_response
+        return function_response, None
+
+    def _handle_function_error_response(
+        self,
+        error_msg: str,
+        tool_call_id: str,
+        function_name: str,
+        function_response: str,
+        messages: List[Message],
+        include_function_failed_message: bool = False,
+    ) -> List[Message]:
+        """
+        Handle error from function call response
+        """
+        # Update tool rules
+        self.last_function_response = function_response
+        self.tool_rules_solver.update_tool_usage(function_name)
+
+        # Extend conversation with function response
+        function_response = package_function_response(False, error_msg)
+        new_message = Message.dict_to_message(
+            agent_id=self.agent_state.id,
+            user_id=self.agent_state.created_by_id,
+            model=self.model,
+            openai_message_dict={
+                "role": "tool",
+                "name": function_name,
+                "content": function_response,
+                "tool_call_id": tool_call_id,
+            },
+        )
+        messages.append(new_message)
+        self.interface.function_message(f"Error: {error_msg}", msg_obj=new_message)
+        if include_function_failed_message:
+            self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=new_message)
+
+        # Return updated messages
+        return messages
 
     def _get_ai_reply(
         self,
@@ -261,6 +302,7 @@ class Agent(BaseAgent):
         backoff_factor: float = 0.5,  # delay multiplier for exponential backoff
         max_delay: float = 10.0,  # max delay between retries
         step_count: Optional[int] = None,
+        last_function_failed: bool = False,
     ) -> ChatCompletionResponse:
         """Get response from LLM API with robust retry mechanism."""
 
@@ -273,6 +315,12 @@ class Agent(BaseAgent):
             else [func for func in agent_state_tool_jsons if func["name"] in allowed_tool_names]
         )
 
+        # Don't allow a tool to be called if it failed last time
+        if last_function_failed and self.tool_rules_solver.last_tool_name:
+            allowed_functions = [f for f in allowed_functions if f["name"] != self.tool_rules_solver.last_tool_name]
+            if not allowed_functions:
+                return None
+
         # For the first message, force the initial tool if one is specified
         force_tool_call = None
         if (
@@ -285,6 +333,7 @@ class Agent(BaseAgent):
         # Force a tool call if exactly one tool is specified
         elif step_count is not None and step_count > 0 and len(allowed_tool_names) == 1:
             force_tool_call = allowed_tool_names[0]
+
         for attempt in range(1, empty_response_retry_limit + 1):
             try:
                 response = create(
@@ -409,21 +458,8 @@ class Agent(BaseAgent):
 
             if not target_letta_tool:
                 error_msg = f"No function named {function_name}"
-                function_response = package_function_response(False, error_msg)
-                messages.append(
-                    Message.dict_to_message(
-                        agent_id=self.agent_state.id,
-                        user_id=self.agent_state.created_by_id,
-                        model=self.model,
-                        openai_message_dict={
-                            "role": "tool",
-                            "name": function_name,
-                            "content": function_response,
-                            "tool_call_id": tool_call_id,
-                        },
-                    )
-                )  # extend conversation with function response
-                self.interface.function_message(f"Error: {error_msg}", msg_obj=messages[-1])
+                function_response = "None"  # more like "never ran?"
+                messages = self._handle_function_error_response(error_msg, tool_call_id, function_name, function_response, messages)
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
             # Failure case 2: function name is OK, but function args are bad JSON
@@ -432,21 +468,8 @@ class Agent(BaseAgent):
                 function_args = parse_json(raw_function_args)
             except Exception:
                 error_msg = f"Error parsing JSON for function '{function_name}' arguments: {function_call.arguments}"
-                function_response = package_function_response(False, error_msg)
-                messages.append(
-                    Message.dict_to_message(
-                        agent_id=self.agent_state.id,
-                        user_id=self.agent_state.created_by_id,
-                        model=self.model,
-                        openai_message_dict={
-                            "role": "tool",
-                            "name": function_name,
-                            "content": function_response,
-                            "tool_call_id": tool_call_id,
-                        },
-                    )
-                )  # extend conversation with function response
-                self.interface.function_message(f"Error: {error_msg}", msg_obj=messages[-1])
+                function_response = "None"  # more like "never ran?"
+                messages = self._handle_function_error_response(error_msg, tool_call_id, function_name, function_response, messages)
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
             # Check if inner thoughts is in the function call arguments (possible apparently if you are using Azure)
@@ -479,7 +502,12 @@ class Agent(BaseAgent):
             self.interface.function_message(f"Running {function_name}({function_args})", msg_obj=messages[-1])
             try:
                 # handle tool execution (sandbox) and state updates
-                function_response = self.execute_tool_and_persist_state(function_name, function_args, target_letta_tool)
+                function_response, sandbox_run_result = self.execute_tool_and_persist_state(function_name, function_args, target_letta_tool)
+
+                if sandbox_run_result and sandbox_run_result.status == "error":
+                    error_msg = f"Error calling function {function_name} with args {function_args}: {sandbox_run_result.stderr}"
+                    messages = self._handle_function_error_response(error_msg, tool_call_id, function_name, function_response, messages)
+                    return messages, False, True  # force a heartbeat to allow agent to handle error
 
                 # handle trunction
                 if function_name in ["conversation_search", "conversation_search_date", "archival_memory_search"]:
@@ -505,45 +533,17 @@ class Agent(BaseAgent):
                 error_msg = get_friendly_error_msg(function_name=function_name, exception_name=type(e).__name__, exception_message=str(e))
                 error_msg_user = f"{error_msg}\n{traceback.format_exc()}"
                 self.logger.error(error_msg_user)
-                function_response = package_function_response(False, error_msg)
-                self.last_function_response = function_response
-                # TODO: truncate error message somehow
-                messages.append(
-                    Message.dict_to_message(
-                        agent_id=self.agent_state.id,
-                        user_id=self.agent_state.created_by_id,
-                        model=self.model,
-                        openai_message_dict={
-                            "role": "tool",
-                            "name": function_name,
-                            "content": function_response,
-                            "tool_call_id": tool_call_id,
-                        },
-                    )
-                )  # extend conversation with function response
-                self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=messages[-1])
-                self.interface.function_message(f"Error: {error_msg}", msg_obj=messages[-1])
+                messages = self._handle_function_error_response(
+                    error_msg, tool_call_id, function_name, function_response, messages, include_function_failed_message=True
+                )
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
             # Step 4: check if function response is an error
             if function_response_string.startswith(ERROR_MESSAGE_PREFIX):
-                function_response = package_function_response(False, function_response_string)
-                # TODO: truncate error message somehow
-                messages.append(
-                    Message.dict_to_message(
-                        agent_id=self.agent_state.id,
-                        user_id=self.agent_state.created_by_id,
-                        model=self.model,
-                        openai_message_dict={
-                            "role": "tool",
-                            "name": function_name,
-                            "content": function_response,
-                            "tool_call_id": tool_call_id,
-                        },
-                    )
-                )  # extend conversation with function response
-                self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=messages[-1])
-                self.interface.function_message(f"Error: {function_response_string}", msg_obj=messages[-1])
+                error_msg = function_response_string
+                messages = self._handle_function_error_response(
+                    error_msg, tool_call_id, function_name, function_response, messages, include_function_failed_message=True
+                )
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
             # If no failures happened along the way: ...
@@ -607,9 +607,11 @@ class Agent(BaseAgent):
         counter = 0
         total_usage = UsageStatistics()
         step_count = 0
+        function_failed = False
         while True:
             kwargs["first_message"] = False
             kwargs["step_count"] = step_count
+            kwargs["last_function_failed"] = function_failed
             step_response = self.inner_step(
                 messages=next_input_message,
                 **kwargs,
@@ -689,6 +691,7 @@ class Agent(BaseAgent):
         step_count: Optional[int] = None,
         metadata: Optional[dict] = None,
         summarize_attempt_count: int = 0,
+        last_function_failed: bool = False,
     ) -> AgentStepResponse:
         """Runs a single step in the agent loop (generates at most one LLM call)"""
 
@@ -723,7 +726,17 @@ class Agent(BaseAgent):
                 first_message=first_message,
                 stream=stream,
                 step_count=step_count,
+                last_function_failed=last_function_failed,
             )
+            if not response:
+                # EDGE CASE: Function call failed AND there's no tools left for agent to call -> return early
+                return AgentStepResponse(
+                    messages=input_message_sequence,
+                    heartbeat_request=False,
+                    function_failed=False,  # NOTE: this is different from other function fails. We force to return early
+                    in_context_memory_warning=False,
+                    usage=UsageStatistics(),
+                )
 
             # Step 3: check if LLM wanted to call a function
             # (if yes) Step 4: call the function

letta/client/client.py

@@ -2950,18 +2950,11 @@ class LocalClient(AbstractClient):
             langchain_tool=langchain_tool,
             additional_imports_module_attr_map=additional_imports_module_attr_map,
         )
-        return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
-
-    def load_crewai_tool(self, crewai_tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
-        tool_create = ToolCreate.from_crewai(
-            crewai_tool=crewai_tool,
-            additional_imports_module_attr_map=additional_imports_module_attr_map,
-        )
-        return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
+        return self.server.tool_manager.create_or_update_langchain_tool(tool_create=tool_create, actor=self.user)
 
     def load_composio_tool(self, action: "ActionType") -> Tool:
         tool_create = ToolCreate.from_composio(action_name=action.name)
-        return self.server.tool_manager.create_or_update_composio_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
+        return self.server.tool_manager.create_or_update_composio_tool(tool_create=tool_create, actor=self.user)
 
     def create_tool(
         self,

letta/functions/helpers.py

@@ -230,9 +230,7 @@ def generate_imported_tool_instantiation_call_str(obj: Any) -> Optional[str]:
 
 
 def is_base_model(obj: Any):
-    from langchain_core.pydantic_v1 import BaseModel as LangChainBaseModel
-
-    return isinstance(obj, BaseModel) or isinstance(obj, LangChainBaseModel)
+    return isinstance(obj, BaseModel)
 
 
 def generate_import_code(module_attr_map: Optional[dict]):

letta/local_llm/utils.py

@@ -11,8 +11,11 @@ import letta.local_llm.llm_chat_completion_wrappers.configurable_wrapper as conf
 import letta.local_llm.llm_chat_completion_wrappers.dolphin as dolphin
 import letta.local_llm.llm_chat_completion_wrappers.llama3 as llama3
 import letta.local_llm.llm_chat_completion_wrappers.zephyr as zephyr
+from letta.log import get_logger
 from letta.schemas.openai.chat_completion_request import Tool, ToolCall
 
+logger = get_logger(__name__)
+
 
 def post_json_auth_request(uri, json_payload, auth_type, auth_key):
     """Send a POST request with a JSON payload and optional authentication"""
@@ -126,8 +129,11 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
                             function_tokens += 2
                             if isinstance(v["items"], dict) and "type" in v["items"]:
                                 function_tokens += len(encoding.encode(v["items"]["type"]))
+                        elif field == "default":
+                            function_tokens += 2
+                            function_tokens += len(encoding.encode(str(v["default"])))
                         else:
-                            warnings.warn(f"num_tokens_from_functions: Unsupported field {field} in function {function}")
+                            logger.warning(f"num_tokens_from_functions: Unsupported field {field} in function {function}")
                 function_tokens += 11
 
         num_tokens += function_tokens

letta/orm/agent.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, List, Optional
 from sqlalchemy import JSON, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.constants import MULTI_AGENT_TOOLS
 from letta.orm.block import Block
 from letta.orm.custom_columns import EmbeddingConfigColumn, LLMConfigColumn, ToolRulesColumn
 from letta.orm.message import Message
@@ -121,12 +120,7 @@ class Agent(SqlalchemyBase, OrganizationMixin):
         # add default rule for having send_message be a terminal tool
         tool_rules = self.tool_rules
         if not tool_rules:
-            tool_rules = [
-                TerminalToolRule(tool_name="send_message"),
-            ]
-
-            for tool_name in MULTI_AGENT_TOOLS:
-                tool_rules.append(TerminalToolRule(tool_name=tool_name))
+            tool_rules = [TerminalToolRule(tool_name="send_message"), TerminalToolRule(tool_name="send_message_to_agent_async")]
 
         state = {
             "id": self.id,

letta/orm/enums.py

@@ -7,6 +7,7 @@ class ToolType(str, Enum):
     LETTA_MEMORY_CORE = "letta_memory_core"
     LETTA_MULTI_AGENT_CORE = "letta_multi_agent_core"
     EXTERNAL_COMPOSIO = "external_composio"
+    EXTERNAL_LANGCHAIN = "external_langchain"
 
 
 class JobType(str, Enum):

letta/schemas/agent.py

@@ -143,6 +143,9 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
         None, description="The environment variables for tool execution specific to this agent."
     )
     memory_variables: Optional[Dict[str, str]] = Field(None, description="The variables that should be set for the agent.")
+    project_id: Optional[str] = Field(None, description="The id of the project the agent belongs to.")
+    template_id: Optional[str] = Field(None, description="The id of the template the agent belongs to.")
+    base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
 
     @field_validator("name")
     @classmethod
@@ -210,6 +213,9 @@ class UpdateAgent(BaseModel):
     tool_exec_environment_variables: Optional[Dict[str, str]] = Field(
         None, description="The environment variables for tool execution specific to this agent."
     )
+    project_id: Optional[str] = Field(None, description="The id of the project the agent belongs to.")
+    template_id: Optional[str] = Field(None, description="The id of the template the agent belongs to.")
+    base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
 
     class Config:
         extra = "ignore"  # Ignores extra fields

letta/schemas/providers.py

@@ -279,7 +279,7 @@ class LMStudioOpenAIProvider(OpenAIProvider):
         from letta.llm_api.openai import openai_get_model_list
 
         # For LMStudio, we want to hit 'GET /api/v0/models' instead of 'GET /v1/models'
-        MODEL_ENDPOINT_URL = f"{self.base_url}/api/v0"
+        MODEL_ENDPOINT_URL = f"{self.base_url.strip('/v1')}/api/v0"
         response = openai_get_model_list(MODEL_ENDPOINT_URL)
 
         """

letta/schemas/tool.py

@@ -79,7 +79,7 @@ class Tool(BaseTool):
             self.json_schema = get_json_schema_from_module(module_name=LETTA_MULTI_AGENT_TOOL_MODULE_NAME, function_name=self.name)
         elif self.tool_type == ToolType.EXTERNAL_COMPOSIO:
             # If it is a composio tool, we generate both the source code and json schema on the fly here
-            # TODO: This is brittle, need to think long term about how to improve this
+            # TODO: Deriving the composio action name is brittle, need to think long term about how to improve this
             try:
                 composio_action = generate_composio_action_from_func_name(self.name)
                 tool_create = ToolCreate.from_composio(composio_action)

letta/server/rest_api/routers/v1/agents.py

@@ -47,6 +47,9 @@ def list_agents(
     after: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(None, description="Limit for pagination"),
     query_text: Optional[str] = Query(None, description="Search agents by name"),
+    project_id: Optional[str] = Query(None, description="Search agents by project id"),
+    template_id: Optional[str] = Query(None, description="Search agents by template id"),
+    base_template_id: Optional[str] = Query(None, description="Search agents by base template id"),
 ):
     """
     List all agents associated with a given user.
@@ -58,16 +61,25 @@ def list_agents(
     kwargs = {
         key: value
         for key, value in {
-            "tags": tags,
-            "match_all_tags": match_all_tags,
             "name": name,
-            "query_text": query_text,
+            "project_id": project_id,
+            "template_id": template_id,
+            "base_template_id": base_template_id,
         }.items()
         if value is not None
     }
 
     # Call list_agents with the dynamic kwargs
-    agents = server.agent_manager.list_agents(actor=actor, before=before, after=after, limit=limit, **kwargs)
+    agents = server.agent_manager.list_agents(
+        actor=actor,
+        before=before,
+        after=after,
+        limit=limit,
+        query_text=query_text,
+        tags=tags,
+        match_all_tags=match_all_tags,
+        **kwargs,
+    )
     return agents
 
 

letta/server/rest_api/routers/v1/tools.py

@@ -66,7 +66,7 @@ def list_tools(
     try:
         actor = server.user_manager.get_user_or_default(user_id=user_id)
         if name is not None:
-            tool = server.tool_manager.get_tool_by_name(name=name, actor=actor)
+            tool = server.tool_manager.get_tool_by_name(tool_name=name, actor=actor)
             return [tool] if tool else []
         return server.tool_manager.list_tools(actor=actor, after=after, limit=limit)
     except Exception as e:
@@ -231,7 +231,7 @@ def add_composio_tool(
 
     try:
         tool_create = ToolCreate.from_composio(action_name=composio_action_name)
-        return server.tool_manager.create_or_update_composio_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=actor)
+        return server.tool_manager.create_or_update_composio_tool(tool_create=tool_create, actor=actor)
     except EnumStringNotFound as e:
         raise HTTPException(
             status_code=400,  # Bad Request

letta/server/server.py

@@ -189,7 +189,7 @@ def db_error_handler():
 
 
 if settings.letta_pg_uri_no_default:
-    print("Creating postgres engine", settings.letta_pg_uri)
+    print("Creating postgres engine")
     config.recall_storage_type = "postgres"
     config.recall_storage_uri = settings.letta_pg_uri_no_default
     config.archival_storage_type = "postgres"
@@ -1000,8 +1000,8 @@ class SyncServer(Server):
         return passage_count, document_count
 
     def list_data_source_passages(self, user_id: str, source_id: str) -> List[Passage]:
-        warnings.warn("list_data_source_passages is not yet implemented, returning empty list.", category=UserWarning)
-        return []
+        # TODO: move this query into PassageManager
+        return self.agent_manager.list_passages(actor=self.user_manager.get_user_or_default(user_id=user_id), source_id=source_id)
 
     def list_all_sources(self, actor: User) -> List[Source]:
         """List all sources (w/ extra metadata) belonging to a user"""

letta/server/startup.sh

@@ -14,7 +14,7 @@ wait_for_postgres() {
 
 # Check if we're configured for external Postgres
 if [ -n "$LETTA_PG_URI" ]; then
-    echo "External Postgres configuration detected, using $LETTA_PG_URI"
+    echo "External Postgres configuration detected, using env var LETTA_PG_URI"
 else
     echo "No external Postgres configuration detected, starting internal PostgreSQL..."
     # Start PostgreSQL using the base image's entrypoint script

letta/services/agent_manager.py

@@ -120,6 +120,9 @@ class AgentManager:
             metadata=agent_create.metadata,
             tool_rules=agent_create.tool_rules,
             actor=actor,
+            project_id=agent_create.project_id,
+            template_id=agent_create.template_id,
+            base_template_id=agent_create.base_template_id,
         )
 
         # If there are provided environment variables, add them in
@@ -179,6 +182,9 @@ class AgentManager:
         description: Optional[str] = None,
         metadata: Optional[Dict] = None,
         tool_rules: Optional[List[PydanticToolRule]] = None,
+        project_id: Optional[str] = None,
+        template_id: Optional[str] = None,
+        base_template_id: Optional[str] = None,
     ) -> PydanticAgentState:
         """Create a new agent."""
         with self.session_maker() as session:
@@ -193,6 +199,9 @@ class AgentManager:
                 "description": description,
                 "metadata_": metadata,
                 "tool_rules": tool_rules,
+                "project_id": project_id,
+                "template_id": template_id,
+                "base_template_id": base_template_id,
             }
 
             # Create the new agent using SqlalchemyBase.create
@@ -242,7 +251,19 @@ class AgentManager:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
             # Update scalar fields directly
-            scalar_fields = {"name", "system", "llm_config", "embedding_config", "message_ids", "tool_rules", "description", "metadata"}
+            scalar_fields = {
+                "name",
+                "system",
+                "llm_config",
+                "embedding_config",
+                "message_ids",
+                "tool_rules",
+                "description",
+                "metadata",
+                "project_id",
+                "template_id",
+                "base_template_id",
+            }
             for field in scalar_fields:
                 value = getattr(agent_update, field, None)
                 if value is not None:

letta/services/passage_manager.py

@@ -1,6 +1,8 @@
 from datetime import datetime
 from typing import List, Optional
 
+from openai import OpenAI
+
 from letta.embeddings import embedding_model, parse_and_chunk_text
 from letta.orm.errors import NoResultFound
 from letta.orm.passage import AgentPassage, SourcePassage
@@ -86,14 +88,31 @@ class PassageManager:
         """Insert passage(s) into archival memory"""
 
         embedding_chunk_size = agent_state.embedding_config.embedding_chunk_size
-        embed_model = embedding_model(agent_state.embedding_config)
+
+        # TODO eventually migrate off of llama-index for embeddings?
+        # Already causing pain for OpenAI proxy endpoints like LM Studio...
+        if agent_state.embedding_config.embedding_endpoint_type != "openai":
+            embed_model = embedding_model(agent_state.embedding_config)
 
         passages = []
 
         try:
             # breakup string into passages
             for text in parse_and_chunk_text(text, embedding_chunk_size):
-                embedding = embed_model.get_text_embedding(text)
+
+                if agent_state.embedding_config.embedding_endpoint_type != "openai":
+                    embedding = embed_model.get_text_embedding(text)
+                else:
+                    # TODO should have the settings passed in via the server call
+                    from letta.settings import model_settings
+
+                    # Simple OpenAI client code
+                    client = OpenAI(
+                        api_key=model_settings.openai_api_key, base_url=agent_state.embedding_config.embedding_endpoint, max_retries=0
+                    )
+                    response = client.embeddings.create(input=text, model=agent_state.embedding_config.embedding_model)
+                    embedding = response.data[0].embedding
+
                 if isinstance(embedding, dict):
                     try:
                         embedding = embedding["data"][0]["embedding"]

letta/services/step_manager.py

@@ -1,4 +1,4 @@
-import datetime
+from datetime import datetime
 from typing import List, Literal, Optional
 
 from sqlalchemy import select

letta/services/tool_manager.py

@@ -11,7 +11,7 @@ from letta.orm.enums import ToolType
 from letta.orm.errors import NoResultFound
 from letta.orm.tool import Tool as ToolModel
 from letta.schemas.tool import Tool as PydanticTool
-from letta.schemas.tool import ToolUpdate
+from letta.schemas.tool import ToolCreate, ToolUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types, printd
 
@@ -57,9 +57,16 @@ class ToolManager:
         return tool
 
     @enforce_types
-    def create_or_update_composio_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
-        pydantic_tool.tool_type = ToolType.EXTERNAL_COMPOSIO
-        return self.create_or_update_tool(pydantic_tool, actor)
+    def create_or_update_composio_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
+        return self.create_or_update_tool(
+            PydanticTool(tool_type=ToolType.EXTERNAL_COMPOSIO, name=tool_create.json_schema["name"], **tool_create.model_dump()), actor
+        )
+
+    @enforce_types
+    def create_or_update_langchain_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
+        return self.create_or_update_tool(
+            PydanticTool(tool_type=ToolType.EXTERNAL_LANGCHAIN, name=tool_create.json_schema["name"], **tool_create.model_dump()), actor
+        )
 
     @enforce_types
     def create_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:

{letta_nightly-0.6.20.dev20250204104033.dist-info → letta_nightly-0.6.21.dev20250205051348.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.20.dev20250204104033
+Version: 0.6.21.dev20250205051348
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.20.dev20250204104033.dist-info → letta_nightly-0.6.21.dev20250205051348.dist-info}/RECORD

@@ -1,6 +1,6 @@
-letta/__init__.py,sha256=EApmTks3-qbEB16_xaPs03NX3OVfVYtxNA3MTpE-oRs,919
+letta/__init__.py,sha256=bjhntPdDAWCs4iINZfoEzpfEiEU32NSYtCmSvdcL3gk,919
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=3-YDxRLMKPrXnmvZ1qstG2MmH9FU9cUQ0cDYZbFQ9eM,56575
+letta/agent.py,sha256=Ds5-t_Ge1ZJf8wbQ2LbpK9LHEs6XNu0xLow3iXoZpd8,56980
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
 letta/benchmark/constants.py,sha256=aXc5gdpMGJT327VuxsT5FngbCK2J41PQYeICBO7g_RE,536
 letta/chat_only_agent.py,sha256=71Lf-df8y3nsE9IFKpEigaZaWHoWnXnhVChkp1L-83I,4760
@@ -8,7 +8,7 @@ letta/cli/cli.py,sha256=_uGKM-RvGLGf7y8iWjkLgLTxIw7uWrdCdL5ETUOCkUs,16472
 letta/cli/cli_config.py,sha256=2oo4vui1GXQarAD6Ru4SRzPvcW4eX2mCXOBusfYGvJw,8533
 letta/cli/cli_load.py,sha256=xFw-CuzjChcIptaqQ1XpDROENt0JSjyPeiQ0nmEeO1k,2706
 letta/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/client/client.py,sha256=-h6V_PUunYouEmw_TI0BalEvQcQ9uIOfLBnDMrDSYQQ,138785
+letta/client/client.py,sha256=Vzjq3a5dx9W5R96FvKkohHf2Yf0NV4XG0VWTH2h0624,138315
 letta/client/streaming.py,sha256=DzE86XJTg_0j9eC45Hrpy9vPt-Wfo1F-sIv_B7iNV6I,5509
 letta/client/utils.py,sha256=VCGV-op5ZSmurd4yw7Vhf93XDQ0BkyBT8qsuV7EqfiU,2859
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
@@ -23,7 +23,7 @@ letta/functions/function_sets/base.py,sha256=bOiitkhzqYKwZBiRYrx29AlordiA5IrXw25
 letta/functions/function_sets/extras.py,sha256=Z9yEdBpQFtTjpxkgbtkWMA8GtDWC6ai2bdsRpnv0H_w,4837
 letta/functions/function_sets/multi_agent.py,sha256=2tu7A_eMwkfXldZWpfwwnq0OXPFTjROo-NjXvuhxOhc,5357
 letta/functions/functions.py,sha256=NyWLh7a-f4mXti5vM1oWDwXzfA58VmVVqL03O9vosKY,5672
-letta/functions/helpers.py,sha256=9mNkjzxDo72Xe7Cg5tgbHUT4VyfHc4dygLUONhmVroo,19815
+letta/functions/helpers.py,sha256=5f4ua21fffqU-M24ha2xNGrqIhqLWh0-sTNFOHbu18Q,19700
 letta/functions/schema_generator.py,sha256=qosgp3p27QRTqOCPLrSkCGVdyQsyTTZunXQ_g-YaTkw,20138
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
 letta/helpers/tool_rule_solver.py,sha256=VnJfqb5L1Lcipc_tBVGj0om60GKQkMkNLgg6X9VZl2c,6210
@@ -73,7 +73,7 @@ letta/local_llm/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 letta/local_llm/settings/deterministic_mirostat.py,sha256=kgRikcxYHfIbPFydHW6W7IO9jmp6NeA7JNAhnI3DPsc,1221
 letta/local_llm/settings/settings.py,sha256=QBuuOLl3OFxN6koBGxFuXSllf4EryQuJCHB5_0IttFU,2962
 letta/local_llm/settings/simple.py,sha256=HAO2jBJ_hJCEsXWIJcD0sckR0tI0zs3x2CPdf6ORQLs,719
-letta/local_llm/utils.py,sha256=fWLAnd-1-HhSBZ0Nf1GOq0qTKhZfN9-UFG896NwT1rU,13485
+letta/local_llm/utils.py,sha256=jvJIhAH0qOXpV5dCqA2jI_3GxcaV6VT-chP7OxihEOU,13735
 letta/local_llm/vllm/api.py,sha256=2kAGZjc_GH9ILJnVRq-45yfsfKELVfbC9VEl_cIC6vg,2590
 letta/local_llm/webui/api.py,sha256=kkxncdCFq1vjgvaHOoQ__j7rcDPgC1F64KcEm94Y6Rs,2639
 letta/local_llm/webui/legacy_api.py,sha256=k3H3y4qp2Fs-XmP24iSIEyvq6wjWFWBzklY3-wRAJNI,2335
@@ -87,13 +87,13 @@ letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 letta/openai_backcompat/openai_object.py,sha256=Y1ZS1sATP60qxJiOsjOP3NbwSzuzvkNAvb3DeuhM5Uk,13490
 letta/orm/__all__.py,sha256=2gh2MZTkA3Hw67VWVKK3JIStJOqTeLdpCvYSVYNeEDA,692
 letta/orm/__init__.py,sha256=wPokP-EvOri2LhKLjmYVtI_FWchaxgFvJeF_NAfqJIo,842
-letta/orm/agent.py,sha256=ucVnPMP7S9YuWcMPxG_CWtT5QH8P2TWSU-Cp1HLuXIU,7385
+letta/orm/agent.py,sha256=sFUzzFf8SPJetHP50DuiRss7YmMFh_gEqcFr6tTmBKg,7245
 letta/orm/agents_tags.py,sha256=dYSnHz4IWBjyOiQ4RJomX3P0QN76JTlEZEw5eJM6Emg,925
 letta/orm/base.py,sha256=VjvxF9TwKF9Trf8BJkDgf7D6KrWWopOkUiF18J3IElk,3071
 letta/orm/block.py,sha256=EjH8lXexHtFIHJ8G-RjNo2oAH834x0Hbn4CER9S4U74,3880
 letta/orm/blocks_agents.py,sha256=W0dykl9OchAofSuAYZD5zNmhyMabPr9LTJrz-I3A0m4,983
 letta/orm/custom_columns.py,sha256=APR3ylle9hUutQoy8m-toTV53F1mpcQhEcnf32XTmQA,5447
-letta/orm/enums.py,sha256=HzX3eXhBH-PnpxhBWtWbkV4J6wrStlJaX_OVdZgAdLU,428
+letta/orm/enums.py,sha256=g4qbX_6a1NQpCt3rScAySbwSbkwqGmnOEaNbkMmCWF4,474
 letta/orm/errors.py,sha256=Se0Guz-gqi-D36NUWSh7AP9zTVCSph9KgZh_trwng4o,734
 letta/orm/file.py,sha256=7_p7LxityP3NQZVURQYG0kgcZhEkVuMN0Fj4h9YOe1w,1780
 letta/orm/job.py,sha256=G2P-xUpTapD4lhU2FwMZET1b5QR4ju9WOB3uiTKD_mw,2157
@@ -139,7 +139,7 @@ letta/prompts/system/memgpt_modified_o1.txt,sha256=objnDgnxpF3-MmU28ZqZ7-TOG8UlH
 letta/prompts/system/memgpt_offline_memory.txt,sha256=rWEJeF-6aiinjkJM9hgLUYCmlEcC_HekYB1bjEUYq6M,2460
 letta/prompts/system/memgpt_offline_memory_chat.txt,sha256=ituh7gDuio7nC2UKFB7GpBq6crxb8bYedQfJ0ADoPgg,3949
 letta/pytest.ini,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/schemas/agent.py,sha256=M09-BY37tqxRkQ8sh16oq7Ay_TOJWoP63Cm6aJxp-SY,12091
+letta/schemas/agent.py,sha256=9Utvls2nMlwixoWaBn6gf5VlgQTnTZxhexK1j2CuSD0,12707
 letta/schemas/block.py,sha256=FYYmRWjH4d4QHMUx_nmIXjv_qJna_l-Ip_4i51wDBPA,5942
 letta/schemas/embedding_config.py,sha256=RkLbUorFkMWr1tPkn6c2aHrnICjWTbhPY86tIncwXyA,3373
 letta/schemas/embedding_config_overrides.py,sha256=lkTa4y-EQ2RnaEKtKDM0sEAk7EwNa67REw8DGNNtGQY,84
@@ -163,12 +163,12 @@ letta/schemas/openai/embedding_response.py,sha256=WKIZpXab1Av7v6sxKG8feW3ZtpQUNo
 letta/schemas/openai/openai.py,sha256=Hilo5BiLAGabzxCwnwfzK5QrWqwYD8epaEKFa4Pwndk,7970
 letta/schemas/organization.py,sha256=WWbUWVSp_VQRFwWN4fdHg1yObiV6x9rZnvIY8x5BPs0,746
 letta/schemas/passage.py,sha256=pdCLZgOn0gWK1gB6aFHLS0gfdWCBqLaiHDA0iQ12Zd8,3704
-letta/schemas/providers.py,sha256=Wd0d0jgv6z3X5t7cT1ZVoX_Qa85ecsm1gQzkOPgQFUo,34890
+letta/schemas/providers.py,sha256=1Sc7gWI6n9RkR4kOY4g3xGLVo6VCSwpiJySp3Pm3MQw,34903
 letta/schemas/run.py,sha256=SRqPRziINIiPunjOhE_NlbnQYgxTvqmbauni_yfBQRA,2085
 letta/schemas/sandbox_config.py,sha256=Nz8K5brqe6jpf66KnTJ0-E7ZeFdPoBFGN-XOI35OeaY,5926
 letta/schemas/source.py,sha256=-BQVolcXA2ziCu2ztR6cbTdGUc8G7vGJy7rvpdf1hpg,2880
 letta/schemas/step.py,sha256=cCmDChQMndy7aMJGH0Z19VbzJkAeFTYuA0cJpzjW2g0,1928
-letta/schemas/tool.py,sha256=uv3WxTt9SzaoXzwTLNHT2wegWTcaBFQBnBvNJrxeYvs,11022
+letta/schemas/tool.py,sha256=dDyzvLZ_gw9DdcFplGTHoH9aFQnF2ez-ApYLRtxAfys,11051
 letta/schemas/tool_rule.py,sha256=tS7ily6NJD8E4n7Hla38jMUe6OIdhdc1ckq0AiRpu5Y,1893
 letta/schemas/usage.py,sha256=8oYRH-JX0PfjIu2zkT5Uu3UWQ7Unnz_uHiO8hRGI4m0,912
 letta/schemas/user.py,sha256=V32Tgl6oqB3KznkxUz12y7agkQicjzW7VocSpj78i6Q,1526
@@ -187,7 +187,7 @@ letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=TjeiyEMkpWR3PBazUWs4W2XVwGVEW5NRTOFXWag62oU,6657
 letta/server/rest_api/routers/v1/__init__.py,sha256=tzD8Oh6ynPkg8ULcITWcwalLL81SIh6eztPqV9l7VGk,1162
-letta/server/rest_api/routers/v1/agents.py,sha256=-eRRQDyWyBnP6aj6z9rJTiaidqPls1TQB1xSqGdIYGA,25041
+letta/server/rest_api/routers/v1/agents.py,sha256=AkoJWxn-cJEURGXBarJtasTJsldPe6vv9TFOiGpJRlY,25473
 letta/server/rest_api/routers/v1/blocks.py,sha256=oJYOpGUTd4AhKwVolVlZPIXO2EoOrBHkyi2PdrmbtmA,3888
 letta/server/rest_api/routers/v1/health.py,sha256=pKCuVESlVOhGIb4VC4K-H82eZqfghmT6kvj2iOkkKuc,401
 letta/server/rest_api/routers/v1/jobs.py,sha256=pKihW12hQdFwt6tHQXs94yOMv6xotlhBB3Vl7Q5ASKQ,2738
@@ -199,12 +199,12 @@ letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=_6WcwgKrgRfnTEC_EgoN-
 letta/server/rest_api/routers/v1/sources.py,sha256=g7NKgbZkS7y1vlukJHZ_yoWrk3AxyoWKTVGszp0Ky18,8414
 letta/server/rest_api/routers/v1/steps.py,sha256=SuZmneaeSSAHjOMatMt_QILLzkNpkbwuVgKiMYr52cE,3038
 letta/server/rest_api/routers/v1/tags.py,sha256=45G0cmcP-ER0OO5OanT_fGtGQfl9ZjRKU97mFwtwyfo,878
-letta/server/rest_api/routers/v1/tools.py,sha256=BS4HsHZLv2n4MauLSrVNlch2TuijzlyEfqKc3fP2b94,12633
+letta/server/rest_api/routers/v1/tools.py,sha256=Ft1wnS7RJT3TOfwSGMJ0_gfTpXnVArZUtPCXT3osI-0,12615
 letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQczIq2Z3YLdbVo,2277
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=dsjkZzgo9Rk3fjUf1ajjiiql1eeO5DAzmXprttI7bJU,3993
-letta/server/server.py,sha256=GensF4fGmRP5-3hGxm6Zr6rQea2XyX-T2dIK277Shjk,59827
-letta/server/startup.sh,sha256=722uKJWB2C4q3vjn39De2zzPacaZNw_1fN1SpLGjKIo,1569
+letta/server/server.py,sha256=8tRXPLta26ARQSThMDnKDAxTGx39j8Zw-41kgEgSpoQ,59850
+letta/server/startup.sh,sha256=qEi6dQHJRzEzDIgnIODj-RYp-O1XstfFpc6cFLkUzVs,1576
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
 letta/server/static_files/favicon.ico,sha256=DezhLdFSbM8o81wCOZcV3riq7tFUOGQD4h6-vr-HuU0,342
@@ -217,29 +217,29 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=M_-gM5iuDBwa1cuN2IGNCG5GxMJwU2d3XW93XALv9s8,1821
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=I6F-nED9Q6O_FY2-O1gHDY-OaQIxbt3FsL88DENVTfE,50287
+letta/services/agent_manager.py,sha256=FLb6Y3_aZSNGTIfUrKJbRTXTMHJBlf8OGH-Ahf0moY0,50958
 letta/services/block_manager.py,sha256=u56TXG46QDMbQZadDGCO7fY1vreJ69Xr_0MUF53xw4k,5519
 letta/services/helpers/agent_manager_helper.py,sha256=RH0MXLZASkP2LVbVNUfSYHrcBYZnVxFd9ejGjRK90Hw,11283
 letta/services/helpers/tool_execution_helper.py,sha256=q8uSiQcX6VH_iNg5VNloZgC2JkH9lIOXBKCXYPx2Yac,6097
 letta/services/job_manager.py,sha256=7awEHraoEmqlDQvcQTEkb_dcZsG9eIYGWYct8exzm2E,13117
 letta/services/message_manager.py,sha256=w6-B9Zz5z9UXcd6mKhinsaCINTsmxDsH9JJsV2_qlH4,8878
 letta/services/organization_manager.py,sha256=h3hrknBhA3YQt90OeBzFnqjYM9NWKnk8jDKzXGm4AUg,3392
-letta/services/passage_manager.py,sha256=INxeNiFAluAkzmCL5jeWWimA3ONUZcck8BuCa0UYajk,7714
+letta/services/passage_manager.py,sha256=oyTFguEa5Z1JgciKHSmQkgC3kV4Q4fV-4NgUQxfxafU,8647
 letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1HVEAhXsAg9-4,546
 letta/services/provider_manager.py,sha256=jEal0A0XWobWH5CVfmzPtcFhsflI-sanqyg26FqpDKk,3575
 letta/services/sandbox_config_manager.py,sha256=eWDNTscRG9Gt_Ixho3-daOOno_9KcebxeA9v_CbzYu0,13371
 letta/services/source_manager.py,sha256=0JLKIv405oS5wc6bY5k2bxxZpS9O-VwUGHVdGPbJ3e4,7676
-letta/services/step_manager.py,sha256=Zpbz6o-KgvGePiQkgd6lHagtpYo3H906vjDE0_hpZVo,4871
+letta/services/step_manager.py,sha256=dvGFeobB7TjXBENG6pGrEr6tEil3Am7GyTzv2IjQifA,4885
 letta/services/tool_execution_sandbox.py,sha256=4XBYkCEBLG6GqijxgqeLIQQJ9zRbsJa8vZ4dZG04Pq8,22080
-letta/services/tool_manager.py,sha256=0zc7bFxGvl_wjs7CC4cyeUWFZAUQK_yVKsUjhrW3Vao,9181
+letta/services/tool_manager.py,sha256=9Y15q0GqnADk-tnUeWDFFsDOt_ZjwsPU2oteDVtHAF4,9572
 letta/services/user_manager.py,sha256=1U8BQ_-MBkEW2wnSFV_OsTwBmRAZLN8uHLFjnDjK3hA,4308
 letta/settings.py,sha256=r9KUE1YU2VfLPsdjTRvv5OfyEhV6CqXwqkeeT6NMznI,6090
 letta/streaming_interface.py,sha256=lo2VAQRUJOdWTijwnXuKOC9uejqr2siUAEmZiQUXkj8,15710
 letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,11946
 letta/system.py,sha256=S_0cod77iEttkFd1bSh2wenLCKA8YL487AuVenIDUng,8425
 letta/utils.py,sha256=lgBDWKmrQrmJGPxcgamFC2aJyi6I0dX7bzLBt3YC6j0,34051
-letta_nightly-0.6.20.dev20250204104033.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.20.dev20250204104033.dist-info/METADATA,sha256=YYWyr6N3zBnbtsnEebVXBEp1D1rDg-7gwQZ-clL2Pv4,22156
-letta_nightly-0.6.20.dev20250204104033.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.20.dev20250204104033.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.20.dev20250204104033.dist-info/RECORD,,
+letta_nightly-0.6.21.dev20250205051348.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.21.dev20250205051348.dist-info/METADATA,sha256=frAZ25QAcs_U__UpdBap5HwnrO-07Bp7zjmEiYL-HHM,22156
+letta_nightly-0.6.21.dev20250205051348.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.21.dev20250205051348.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.21.dev20250205051348.dist-info/RECORD,,