letta-nightly 0.1.7.dev20240930104151__py3-none-any.whl → 0.1.7.dev20241002104051__py3-none-any.whl

letta/agent.py

@@ -237,10 +237,8 @@ class Agent(BaseAgent):
         self.agent_state = agent_state
         assert isinstance(self.agent_state.memory, Memory), f"Memory object is not of type Memory: {type(self.agent_state.memory)}"
 
-        try:
-            self.link_tools(tools)
-        except Exception as e:
-            raise ValueError(f"Encountered an error while trying to link agent tools during initialization:\n{str(e)}")
+        # link tools
+        self.link_tools(tools)
 
         # gpt-4, gpt-3.5-turbo, ...
         self.model = self.agent_state.llm_config.model
@@ -345,13 +343,18 @@ class Agent(BaseAgent):
         env = {}
         env.update(globals())
         for tool in tools:
-            # WARNING: name may not be consistent?
-            if tool.module:  # execute the whole module
-                exec(tool.module, env)
-            else:
-                exec(tool.source_code, env)
-            self.functions_python[tool.name] = env[tool.name]
-            self.functions.append(tool.json_schema)
+            try:
+                # WARNING: name may not be consistent?
+                if tool.module:  # execute the whole module
+                    exec(tool.module, env)
+                else:
+                    exec(tool.source_code, env)
+
+                self.functions_python[tool.json_schema["name"]] = env[tool.json_schema["name"]]
+                self.functions.append(tool.json_schema)
+            except Exception as e:
+                warnings.warn(f"WARNING: tool {tool.name} failed to link")
+                print(e)
         assert all([callable(f) for k, f in self.functions_python.items()]), self.functions_python
 
     def _load_messages_from_recall(self, message_ids: List[str]) -> List[Message]:
@@ -548,18 +551,19 @@ class Agent(BaseAgent):
             )  # extend conversation with assistant's reply
             printd(f"Function call message: {messages[-1]}")
 
-            # The content if then internal monologue, not chat
-            self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
+            if response_message.content:
+                # The content if then internal monologue, not chat
+                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
 
             # Step 3: call the function
             # Note: the JSON response may not always be valid; be sure to handle errors
-
-            # Failure case 1: function name is wrong
             function_call = (
                 response_message.function_call if response_message.function_call is not None else response_message.tool_calls[0].function
             )
             function_name = function_call.name
             printd(f"Request to call function {function_name} with tool_call_id: {tool_call_id}")
+
+            # Failure case 1: function name is wrong
             try:
                 function_to_call = self.functions_python[function_name]
             except KeyError:
@@ -1114,48 +1118,10 @@ class Agent(BaseAgent):
     def add_function(self, function_name: str) -> str:
         # TODO: refactor
         raise NotImplementedError
-        # if function_name in self.functions_python.keys():
-        #    msg = f"Function {function_name} already loaded"
-        #    printd(msg)
-        #    return msg
-
-        # available_functions = load_all_function_sets()
-        # if function_name not in available_functions.keys():
-        #    raise ValueError(f"Function {function_name} not found in function library")
-
-        # self.functions.append(available_functions[function_name]["json_schema"])
-        # self.functions_python[function_name] = available_functions[function_name]["python_function"]
-
-        # msg = f"Added function {function_name}"
-        ## self.save()
-        # self.update_state()
-        # printd(msg)
-        # return msg
 
     def remove_function(self, function_name: str) -> str:
         # TODO: refactor
         raise NotImplementedError
-        # if function_name not in self.functions_python.keys():
-        #    msg = f"Function {function_name} not loaded, ignoring"
-        #    printd(msg)
-        #    return msg
-
-        ## only allow removal of user defined functions
-        # user_func_path = Path(USER_FUNCTIONS_DIR)
-        # func_path = Path(inspect.getfile(self.functions_python[function_name]))
-        # is_subpath = func_path.resolve().parts[: len(user_func_path.resolve().parts)] == user_func_path.resolve().parts
-
-        # if not is_subpath:
-        #    raise ValueError(f"Function {function_name} is not user defined and cannot be removed")
-
-        # self.functions = [f_schema for f_schema in self.functions if f_schema["name"] != function_name]
-        # self.functions_python.pop(function_name)
-
-        # msg = f"Removed function {function_name}"
-        ## self.save()
-        # self.update_state()
-        # printd(msg)
-        # return msg
 
     def update_state(self) -> AgentState:
         message_ids = [msg.id for msg in self._messages]

letta/cli/cli.py

@@ -464,7 +464,6 @@ def run(
     # read user id from config
     ms = MetadataStore(config)
     client = create_client()
-    client.user_id
 
     # determine agent to use, if not provided
     if not yes and not agent:

letta/cli/cli_load.py

@@ -18,56 +18,6 @@ from letta.data_sources.connectors import DirectoryConnector
 
 app = typer.Typer()
 
-# NOTE: not supported due to llama-index breaking things (please reach out if you still need it)
-# @app.command("index")
-# def load_index(
-#    name: Annotated[str, typer.Option(help="Name of dataset to load.")],
-#    dir: Annotated[Optional[str], typer.Option(help="Path to directory containing index.")] = None,
-#    user_id: Annotated[Optional[uuid.UUID], typer.Option(help="User ID to associate with dataset.")] = None,
-# ):
-#    """Load a LlamaIndex saved VectorIndex into Letta"""
-#    if user_id is None:
-#        config = LettaConfig.load()
-#        user_id = uuid.UUID(config.anon_clientid)
-#
-#    try:
-#        # load index data
-#        storage_context = StorageContext.from_defaults(persist_dir=dir)
-#        loaded_index = load_index_from_storage(storage_context)
-#
-#        # hacky code to extract out passages/embeddings (thanks a lot, llama index)
-#        embed_dict = loaded_index._vector_store._data.embedding_dict
-#        node_dict = loaded_index._docstore.docs
-#
-#        # create storage connector
-#        config = LettaConfig.load()
-#        if user_id is None:
-#            user_id = uuid.UUID(config.anon_clientid)
-#
-#        passages = []
-#        for node_id, node in node_dict.items():
-#            vector = embed_dict[node_id]
-#            node.embedding = vector
-#            # assume embedding are the same as config
-#            passages.append(
-#                Passage(
-#                    text=node.text,
-#                    embedding=np.array(vector),
-#                    embedding_dim=config.default_embedding_config.embedding_dim,
-#                    embedding_model=config.default_embedding_config.embedding_model,
-#                )
-#            )
-#            assert config.default_embedding_config.embedding_dim == len(
-#                vector
-#            ), f"Expected embedding dimension {config.default_embedding_config.embedding_dim}, got {len(vector)}"
-#
-#        if len(passages) == 0:
-#            raise ValueError(f"No passages found in index {dir}")
-#
-#        insert_passages_into_source(passages, name, user_id, config)
-#    except ValueError as e:
-#        typer.secho(f"Failed to load index from provided information.\n{e}", fg=typer.colors.RED)
-
 
 default_extensions = ".txt,.md,.pdf"
 

letta/client/client.py

@@ -1562,7 +1562,7 @@ class LocalClient(AbstractClient):
 
     def get_agent(self, agent_id: str) -> AgentState:
         """
-        Get an agent's state by it's ID.
+        Get an agent's state by its ID.
 
         Args:
             agent_id (str): ID of the agent

letta/config.py

@@ -2,7 +2,6 @@ import configparser
 import inspect
 import json
 import os
-import uuid
 from dataclasses import dataclass
 from typing import Optional
 
@@ -14,6 +13,7 @@ from letta.constants import (
     DEFAULT_HUMAN,
     DEFAULT_PERSONA,
     DEFAULT_PRESET,
+    DEFAULT_USER_ID,
     LETTA_DIR,
 )
 from letta.log import get_logger
@@ -45,7 +45,7 @@ def set_field(config, section, field, value):
 @dataclass
 class LettaConfig:
     config_path: str = os.getenv("MEMGPT_CONFIG_PATH") or os.path.join(LETTA_DIR, "config")
-    anon_clientid: str = str(uuid.UUID(int=0))
+    anon_clientid: str = DEFAULT_USER_ID
 
     # preset
     preset: str = DEFAULT_PRESET  # TODO: rename to system prompt
@@ -100,10 +100,6 @@ class LettaConfig:
         # self.context_window = int(self.context_window)
         pass
 
-    @staticmethod
-    def generate_uuid() -> str:
-        return uuid.UUID(int=uuid.getnode()).hex
-
     @classmethod
     def load(cls, llm_config: Optional[LLMConfig] = None, embedding_config: Optional[EmbeddingConfig] = None) -> "LettaConfig":
         # avoid circular import
@@ -199,8 +195,7 @@ class LettaConfig:
         # assert llm_config is not None, "LLM config must be provided if config does not exist"
 
         # create new config
-        anon_clientid = LettaConfig.generate_uuid()
-        config = cls(anon_clientid=anon_clientid, config_path=config_path)
+        config = cls(config_path=config_path)
 
         config.create_config_dir()  # create dirs
 
@@ -284,8 +279,6 @@ class LettaConfig:
         set_field(config, "version", "letta_version", letta.__version__)
 
         # client
-        if not self.anon_clientid:
-            self.anon_clientid = self.generate_uuid()
         set_field(config, "client", "anon_clientid", self.anon_clientid)
 
         # always make sure all directories are present

letta/functions/functions.py

@@ -1,17 +1,12 @@
 import importlib
 import inspect
 import os
-import sys
 from textwrap import dedent  # remove indentation
 from types import ModuleType
 
-from letta.constants import CLI_WARNING_PREFIX, LETTA_DIR
+from letta.constants import CLI_WARNING_PREFIX
 from letta.functions.schema_generator import generate_schema
 
-USER_FUNCTIONS_DIR = os.path.join(LETTA_DIR, "functions")
-
-sys.path.append(USER_FUNCTIONS_DIR)
-
 
 def parse_source_code(func) -> str:
     """Parse the source code of a function and remove indendation"""
@@ -68,24 +63,6 @@ def validate_function(module_name, module_full_path):
     return True, None
 
 
-def write_function(module_name: str, function_name: str, function_code: str):
-    """Write a function to a file in the user functions directory"""
-    # Create the user functions directory if it doesn't exist
-    if not os.path.exists(USER_FUNCTIONS_DIR):
-        os.makedirs(USER_FUNCTIONS_DIR)
-
-    # Write the function to a file
-    file_path = os.path.join(USER_FUNCTIONS_DIR, f"{module_name}.py")
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(function_code)
-    succ, error = validate_function(module_name, file_path)
-
-    # raise error if function cannot be loaded
-    if not succ:
-        raise ValueError(error)
-    return file_path
-
-
 def load_function_file(filepath: str) -> dict:
     file = os.path.basename(filepath)
     module_name = file[:-3]  # Remove '.py' from filename

letta/functions/helpers.py

@@ -0,0 +1,191 @@
+from typing import Any, Optional, Union
+
+from pydantic import BaseModel
+
+
+def generate_langchain_tool_wrapper(
+    tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None
+) -> tuple[str, str]:
+    tool_name = tool.__class__.__name__
+    import_statement = f"from langchain_community.tools import {tool_name}"
+    extra_module_imports = generate_import_code(additional_imports_module_attr_map)
+
+    # Safety check that user has passed in all required imports:
+    assert_all_classes_are_imported(tool, additional_imports_module_attr_map)
+
+    tool_instantiation = f"tool = {generate_imported_tool_instantiation_call_str(tool)}"
+    run_call = f"return tool._run(**kwargs)"
+    func_name = f"run_{tool_name.lower()}"
+
+    # Combine all parts into the wrapper function
+    wrapper_function_str = f"""
+def {func_name}(**kwargs):
+    if 'self' in kwargs:
+        del kwargs['self']
+    import importlib
+    {import_statement}
+    {extra_module_imports}
+    {tool_instantiation}
+    {run_call}
+"""
+    return func_name, wrapper_function_str
+
+
+def generate_crewai_tool_wrapper(tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> tuple[str, str]:
+    tool_name = tool.__class__.__name__
+    import_statement = f"from crewai_tools import {tool_name}"
+    extra_module_imports = generate_import_code(additional_imports_module_attr_map)
+
+    # Safety check that user has passed in all required imports:
+    assert_all_classes_are_imported(tool, additional_imports_module_attr_map)
+
+    tool_instantiation = f"tool = {generate_imported_tool_instantiation_call_str(tool)}"
+    run_call = f"return tool._run(**kwargs)"
+    func_name = f"run_{tool_name.lower()}"
+
+    # Combine all parts into the wrapper function
+    wrapper_function_str = f"""
+def {func_name}(**kwargs):
+    if 'self' in kwargs:
+        del kwargs['self']
+    {import_statement}
+    {extra_module_imports}
+    {tool_instantiation}
+    {run_call}
+"""
+    return func_name, wrapper_function_str
+
+
+def assert_all_classes_are_imported(
+    tool: Union["LangChainBaseTool", "CrewAIBaseTool"], additional_imports_module_attr_map: dict[str, str]
+) -> None:
+    # Safety check that user has passed in all required imports:
+    tool_name = tool.__class__.__name__
+    current_class_imports = {tool_name}
+    if additional_imports_module_attr_map:
+        current_class_imports.update(set(additional_imports_module_attr_map.values()))
+    required_class_imports = set(find_required_class_names_for_import(tool))
+
+    if not current_class_imports.issuperset(required_class_imports):
+        err_msg = f"[ERROR] You are missing module_attr pairs in `additional_imports_module_attr_map`. Currently, you have imports for {current_class_imports}, but the required classes for import are {required_class_imports}"
+        print(err_msg)
+        raise RuntimeError(err_msg)
+
+
+def find_required_class_names_for_import(obj: Union["LangChainBaseTool", "CrewAIBaseTool", BaseModel]) -> list[str]:
+    """
+    Finds all the class names for required imports when instantiating the `obj`.
+    NOTE: This does not return the full import path, only the class name.
+
+    We accomplish this by running BFS and deep searching all the BaseModel objects in the obj parameters.
+    """
+    class_names = {obj.__class__.__name__}
+    queue = [obj]
+
+    while queue:
+        # Get the current object we are inspecting
+        curr_obj = queue.pop()
+
+        # Collect all possible candidates for BaseModel objects
+        candidates = []
+        if is_base_model(curr_obj):
+            # If it is a base model, we get all the values of the object parameters
+            # i.e., if obj('b' = <class A>), we would want to inspect <class A>
+            fields = dict(curr_obj)
+            # Generate code for each field, skipping empty or None values
+            candidates = list(fields.values())
+        elif isinstance(curr_obj, dict):
+            # If it is a dictionary, we get all the values
+            # i.e., if obj = {'a': 3, 'b': <class A>}, we would want to inspect <class A>
+            candidates = list(curr_obj.values())
+        elif isinstance(curr_obj, list):
+            # If it is a list, we inspect all the items in the list
+            # i.e., if obj = ['a', 3, None, <class A>], we would want to inspect <class A>
+            candidates = curr_obj
+
+        # Filter out all candidates that are not BaseModels
+        # In the list example above, ['a', 3, None, <class A>], we want to filter out 'a', 3, and None
+        candidates = filter(lambda x: is_base_model(x), candidates)
+
+        # Classic BFS here
+        for c in candidates:
+            c_name = c.__class__.__name__
+            if c_name not in class_names:
+                class_names.add(c_name)
+                queue.append(c)
+
+    return list(class_names)
+
+
+def generate_imported_tool_instantiation_call_str(obj: Any) -> Optional[str]:
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        # This is the base case
+        # If it is a basic Python type, we trivially return the string version of that value
+        # Handle basic types
+        return repr(obj)
+    elif is_base_model(obj):
+        # Otherwise, if it is a BaseModel
+        # We want to pull out all the parameters, and reformat them into strings
+        # e.g. {arg}={value}
+        # The reason why this is recursive, is because the value can be another BaseModel that we need to stringify
+        model_name = obj.__class__.__name__
+        fields = dict(obj)
+        # Generate code for each field, skipping empty or None values
+        field_assignments = []
+        for arg, value in fields.items():
+            python_string = generate_imported_tool_instantiation_call_str(value)
+            if python_string:
+                field_assignments.append(f"{arg}={python_string}")
+
+        assignments = ", ".join(field_assignments)
+        return f"{model_name}({assignments})"
+    elif isinstance(obj, dict):
+        # Inspect each of the items in the dict and stringify them
+        # This is important because the dictionary may contain other BaseModels
+        dict_items = []
+        for k, v in obj.items():
+            python_string = generate_imported_tool_instantiation_call_str(v)
+            if python_string:
+                dict_items.append(f"{repr(k)}: {python_string}")
+
+        joined_items = ", ".join(dict_items)
+        return f"{{{joined_items}}}"
+    elif isinstance(obj, list):
+        # Inspect each of the items in the list and stringify them
+        # This is important because the list may contain other BaseModels
+        list_items = [generate_imported_tool_instantiation_call_str(v) for v in obj]
+        filtered_list_items = list(filter(None, list_items))
+        list_items = ", ".join(filtered_list_items)
+        return f"[{list_items}]"
+    else:
+        # Otherwise, if it is none of the above, that usually means it is a custom Python class that is NOT a BaseModel
+        # Thus, we cannot get enough information about it to stringify it
+        # This may cause issues, but we are making the assumption that any of these custom Python types are handled correctly by the parent library, such as LangChain or CrewAI
+        # An example would be that WikipediaAPIWrapper has an argument that is a wikipedia (pip install wikipedia) object
+        # We cannot stringify this easily, but WikipediaAPIWrapper handles the setting of this parameter internally
+        # This assumption seems fair to me, since usually they are external imports, and LangChain and CrewAI should be bundling those as module-level imports within the tool
+        # We throw a warning here anyway and provide the class name
+        print(
+            f"[WARNING] Skipping parsing unknown class {obj.__class__.__name__} (does not inherit from the Pydantic BaseModel and is not a basic Python type)"
+        )
+        return None
+
+
+def is_base_model(obj: Any):
+    from crewai_tools.tools.base_tool import BaseModel as CrewAiBaseModel
+    from langchain_core.pydantic_v1 import BaseModel as LangChainBaseModel
+
+    return isinstance(obj, BaseModel) or isinstance(obj, LangChainBaseModel) or isinstance(obj, CrewAiBaseModel)
+
+
+def generate_import_code(module_attr_map: Optional[dict]):
+    if not module_attr_map:
+        return ""
+
+    code_lines = []
+    for module, attr in module_attr_map.items():
+        module_name = module.split(".")[-1]
+        code_lines.append(f"# Load the module\n    {module_name} = importlib.import_module('{module}')")
+        code_lines.append(f"    # Access the {attr} from the module")
+        code_lines.append(f"    {attr} = getattr({module_name}, '{attr}')")
+    return "\n".join(code_lines)

letta/functions/schema_generator.py

@@ -1,6 +1,5 @@
 import inspect
-import typing
-from typing import Any, Dict, Optional, Type, get_args, get_origin
+from typing import Any, Dict, Optional, Type, Union, get_args, get_origin
 
 from docstring_parser import parse
 from pydantic import BaseModel
@@ -8,7 +7,7 @@ from pydantic import BaseModel
 
 def is_optional(annotation):
     # Check if the annotation is a Union
-    if getattr(annotation, "__origin__", None) is typing.Union:
+    if getattr(annotation, "__origin__", None) is Union:
         # Check if None is one of the options in the Union
         return type(None) in annotation.__args__
     return False
@@ -164,42 +163,3 @@ def generate_schema_from_args_schema(
     }
 
     return function_call_json
-
-
-def generate_langchain_tool_wrapper(tool_name: str) -> str:
-    import_statement = f"from langchain_community.tools import {tool_name}"
-
-    # NOTE: this will fail for tools like 'wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())' since it needs to pass an argument to the tool instantiation
-    # https://python.langchain.com/v0.1/docs/integrations/tools/wikipedia/
-    tool_instantiation = f"tool = {tool_name}()"
-    run_call = f"return tool._run(**kwargs)"
-    func_name = f"run_{tool_name.lower()}"
-
-    # Combine all parts into the wrapper function
-    wrapper_function_str = f"""
-def {func_name}(**kwargs):
-    if 'self' in kwargs:
-        del kwargs['self']
-    {import_statement}
-    {tool_instantiation}
-    {run_call}
-"""
-    return func_name, wrapper_function_str
-
-
-def generate_crewai_tool_wrapper(tool_name: str) -> str:
-    import_statement = f"from crewai_tools import {tool_name}"
-    tool_instantiation = f"tool = {tool_name}()"
-    run_call = f"return tool._run(**kwargs)"
-    func_name = f"run_{tool_name.lower()}"
-
-    # Combine all parts into the wrapper function
-    wrapper_function_str = f"""
-def {func_name}(**kwargs):
-    if 'self' in kwargs:
-        del kwargs['self']
-    {import_statement}
-    {tool_instantiation}
-    {run_call}
-"""
-    return func_name, wrapper_function_str

letta/schemas/tool.py

@@ -2,11 +2,11 @@ from typing import Dict, List, Optional
 
 from pydantic import Field
 
-from letta.functions.schema_generator import (
+from letta.functions.helpers import (
     generate_crewai_tool_wrapper,
     generate_langchain_tool_wrapper,
-    generate_schema_from_args_schema,
 )
+from letta.functions.schema_generator import generate_schema_from_args_schema
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.openai.chat_completions import ToolCall
 
@@ -58,12 +58,13 @@ class Tool(BaseTool):
         )
 
     @classmethod
-    def from_langchain(cls, langchain_tool) -> "Tool":
+    def from_langchain(cls, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> "Tool":
         """
         Class method to create an instance of Tool from a Langchain tool (must be from langchain_community.tools).
 
         Args:
-            langchain_tool (LangchainTool): An instance of a crewAI BaseTool (BaseTool from crewai)
+            langchain_tool (LangChainBaseTool): An instance of a crewAI BaseTool (BaseTool from crewai)
+            additional_imports_module_attr_map (dict[str, str]): A mapping of module names to attribute name. This is used internally to import all the required classes for the langchain tool. For example, you would pass in `{"langchain_community.utilities": "WikipediaAPIWrapper"}` for `from langchain_community.tools import WikipediaQueryRun`. NOTE: You do NOT need to specify the tool import here, that is done automatically for you.
 
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the provided crewAI BaseTool object.
@@ -72,7 +73,7 @@ class Tool(BaseTool):
         source_type = "python"
         tags = ["langchain"]
         # NOTE: langchain tools may come from different packages
-        wrapper_func_name, wrapper_function_str = generate_langchain_tool_wrapper(langchain_tool.__class__.__name__)
+        wrapper_func_name, wrapper_function_str = generate_langchain_tool_wrapper(langchain_tool, additional_imports_module_attr_map)
         json_schema = generate_schema_from_args_schema(langchain_tool.args_schema, name=wrapper_func_name, description=description)
 
         # append heartbeat (necessary for triggering another reasoning step after this tool call)
@@ -92,7 +93,7 @@ class Tool(BaseTool):
         )
 
     @classmethod
-    def from_crewai(cls, crewai_tool) -> "Tool":
+    def from_crewai(cls, crewai_tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> "Tool":
         """
         Class method to create an instance of Tool from a crewAI BaseTool object.
 
@@ -102,11 +103,10 @@ class Tool(BaseTool):
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the provided crewAI BaseTool object.
         """
-        crewai_tool.name
         description = crewai_tool.description
         source_type = "python"
         tags = ["crew-ai"]
-        wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool.__class__.__name__)
+        wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool, additional_imports_module_attr_map)
         json_schema = generate_schema_from_args_schema(crewai_tool.args_schema, name=wrapper_func_name, description=description)
 
         # append heartbeat (necessary for triggering another reasoning step after this tool call)
@@ -128,7 +128,7 @@ class Tool(BaseTool):
 
 class ToolCreate(BaseTool):
     name: Optional[str] = Field(None, description="The name of the function (auto-generated from source_code if not provided).")
-    tags: List[str] = Field(..., description="Metadata tags.")
+    tags: List[str] = Field([], description="Metadata tags.")
     source_code: str = Field(..., description="The source code of the function.")
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"

letta/server/server.py

@@ -1441,10 +1441,6 @@ class SyncServer(Server):
             logger.exception(f"Failed to delete agent {agent_id} via ID with:\n{str(e)}")
             raise ValueError(f"Failed to delete agent {agent_id} in database")
 
-    def authenticate_user(self) -> str:
-        # TODO: Implement actual authentication to enable multi user setup
-        return str(LettaConfig.load().anon_clientid)
-
     def api_key_to_user(self, api_key: str) -> str:
         """Decode an API key to a user"""
         user = self.ms.get_user_from_api_key(api_key=api_key)
@@ -1752,7 +1748,7 @@ class SyncServer(Server):
 
             # TODO: not sure if this always works
             func = env[functions[-1]]
-            json_schema = generate_schema(func, request.name)
+            json_schema = generate_schema(func)
         else:
             # provided by client
             json_schema = request.json_schema
@@ -1973,19 +1969,6 @@ class SyncServer(Server):
                 return current_user
 
         return self.get_default_user()
-        ## NOTE: same code as local client to get the default user
-        # config = LettaConfig.load()
-        # user_id = config.anon_clientid
-        # user = self.get_user(user_id)
-
-        # if not user:
-        #    user = self.create_user(UserCreate())
-
-        #    # # update config
-        #    config.anon_clientid = str(user.id)
-        #    config.save()
-
-        # return user
 
     def list_models(self) -> List[LLMConfig]:
         """List available models"""