letta-nightly 0.1.7.dev20240924104148__py3-none-any.whl

letta/functions/schema_generator.py

@@ -0,0 +1,205 @@
+import inspect
+import typing
+from typing import Any, Dict, Optional, Type, get_args, get_origin
+
+from docstring_parser import parse
+from pydantic import BaseModel
+
+
+def is_optional(annotation):
+    # Check if the annotation is a Union
+    if getattr(annotation, "__origin__", None) is typing.Union:
+        # Check if None is one of the options in the Union
+        return type(None) in annotation.__args__
+    return False
+
+
+def optional_length(annotation):
+    if is_optional(annotation):
+        # Subtract 1 to account for NoneType
+        return len(annotation.__args__) - 1
+    else:
+        raise ValueError("The annotation is not an Optional type")
+
+
+def type_to_json_schema_type(py_type):
+    """
+    Maps a Python type to a JSON schema type.
+    Specifically handles typing.Optional and common Python types.
+    """
+    # if get_origin(py_type) is typing.Optional:
+    if is_optional(py_type):
+        # Assert that Optional has only one type argument
+        type_args = get_args(py_type)
+        assert optional_length(py_type) == 1, f"Optional type must have exactly one type argument, but got {py_type}"
+
+        # Extract and map the inner type
+        return type_to_json_schema_type(type_args[0])
+
+    # Mapping of Python types to JSON schema types
+    type_map = {
+        int: "integer",
+        str: "string",
+        bool: "boolean",
+        float: "number",
+        list[str]: "array",
+        # Add more mappings as needed
+    }
+    if py_type not in type_map:
+        raise ValueError(f"Python type {py_type} has no corresponding JSON schema type")
+
+    return type_map.get(py_type, "string")  # Default to "string" if type not in map
+
+
+def pydantic_model_to_open_ai(model):
+    schema = model.model_json_schema()
+    docstring = parse(model.__doc__ or "")
+    parameters = {k: v for k, v in schema.items() if k not in ("title", "description")}
+    for param in docstring.params:
+        if (name := param.arg_name) in parameters["properties"] and (description := param.description):
+            if "description" not in parameters["properties"][name]:
+                parameters["properties"][name]["description"] = description
+
+    parameters["required"] = sorted(k for k, v in parameters["properties"].items() if "default" not in v)
+
+    if "description" not in schema:
+        if docstring.short_description:
+            schema["description"] = docstring.short_description
+        else:
+            raise
+
+    return {
+        "name": schema["title"],
+        "description": schema["description"],
+        "parameters": parameters,
+    }
+
+
+def generate_schema(function, name: Optional[str] = None, description: Optional[str] = None):
+    # Get the signature of the function
+    sig = inspect.signature(function)
+
+    # Parse the docstring
+    docstring = parse(function.__doc__)
+
+    # Prepare the schema dictionary
+    schema = {
+        "name": function.__name__ if name is None else name,
+        "description": docstring.short_description if description is None else description,
+        "parameters": {"type": "object", "properties": {}, "required": []},
+    }
+
+    # TODO: ensure that 'agent' keyword is reserved for `Agent` class
+
+    for param in sig.parameters.values():
+        # Exclude 'self' parameter
+        if param.name == "self":
+            continue
+
+        # Assert that the parameter has a type annotation
+        if param.annotation == inspect.Parameter.empty:
+            raise TypeError(f"Parameter '{param.name}' in function '{function.__name__}' lacks a type annotation")
+
+        # Find the parameter's description in the docstring
+        param_doc = next((d for d in docstring.params if d.arg_name == param.name), None)
+
+        # Assert that the parameter has a description
+        if not param_doc or not param_doc.description:
+            raise ValueError(f"Parameter '{param.name}' in function '{function.__name__}' lacks a description in the docstring")
+
+        if inspect.isclass(param.annotation) and issubclass(param.annotation, BaseModel):
+            schema["parameters"]["properties"][param.name] = pydantic_model_to_open_ai(param.annotation)
+        else:
+            # Add parameter details to the schema
+            param_doc = next((d for d in docstring.params if d.arg_name == param.name), None)
+            schema["parameters"]["properties"][param.name] = {
+                # "type": "string" if param.annotation == str else str(param.annotation),
+                "type": type_to_json_schema_type(param.annotation) if param.annotation != inspect.Parameter.empty else "string",
+                "description": param_doc.description,
+            }
+        if param.default == inspect.Parameter.empty:
+            schema["parameters"]["required"].append(param.name)
+
+        if get_origin(param.annotation) is list:
+            if get_args(param.annotation)[0] is str:
+                schema["parameters"]["properties"][param.name]["items"] = {"type": "string"}
+
+        if param.annotation == inspect.Parameter.empty:
+            schema["parameters"]["required"].append(param.name)
+
+    # append the heartbeat
+    if function.__name__ not in ["send_message", "pause_heartbeats"]:
+        schema["parameters"]["properties"]["request_heartbeat"] = {
+            "type": "boolean",
+            "description": "Request an immediate heartbeat after function execution. Set to 'true' if you want to send a follow-up message or run a follow-up function.",
+        }
+        schema["parameters"]["required"].append("request_heartbeat")
+
+    return schema
+
+
+def generate_schema_from_args_schema(
+    args_schema: Type[BaseModel], name: Optional[str] = None, description: Optional[str] = None
+) -> Dict[str, Any]:
+    properties = {}
+    required = []
+    for field_name, field in args_schema.__fields__.items():
+        if field.type_.__name__ == "str":
+            field_type = "string"
+        elif field.type_.__name__ == "int":
+            field_type = "integer"
+        elif field.type_.__name__ == "bool":
+            field_type = "boolean"
+        else:
+            field_type = field.type_.__name__
+        properties[field_name] = {"type": field_type, "description": field.field_info.description}
+        if field.required:
+            required.append(field_name)
+
+    # Construct the OpenAI function call JSON object
+    function_call_json = {
+        "name": name,
+        "description": description,
+        "parameters": {"type": "object", "properties": properties, "required": required},
+    }
+
+    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/humans/examples/basic.txt

@@ -0,0 +1 @@
+First name: Chad

letta/humans/examples/cs_phd.txt

@@ -0,0 +1,9 @@
+This is what I know so far about the user, I should expand this as I learn more about them.
+
+First name: Chad
+Last name: ?
+Gender: Male
+Age: ?
+Nationality: ?
+Occupation: Computer science PhD student at UC Berkeley
+Interests: Formula 1, Sailing, Taste of the Himalayas Restaurant in Berkeley, CSGO

letta/interface.py

@@ -0,0 +1,314 @@
+import re
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+from colorama import Fore, Style, init
+
+from letta.constants import CLI_WARNING_PREFIX
+from letta.schemas.message import Message
+from letta.utils import json_loads, printd
+
+init(autoreset=True)
+
+# DEBUG = True  # puts full message outputs in the terminal
+DEBUG = False  # only dumps important messages in the terminal
+
+STRIP_UI = False
+
+
+class AgentInterface(ABC):
+    """Interfaces handle Letta-related events (observer pattern)
+
+    The 'msg' args provides the scoped message, and the optional Message arg can provide additional metadata.
+    """
+
+    @abstractmethod
+    def user_message(self, msg: str, msg_obj: Optional[Message] = None):
+        """Letta receives a user message"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def internal_monologue(self, msg: str, msg_obj: Optional[Message] = None):
+        """Letta generates some internal monologue"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def assistant_message(self, msg: str, msg_obj: Optional[Message] = None):
+        """Letta uses send_message"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def function_message(self, msg: str, msg_obj: Optional[Message] = None):
+        """Letta calls a function"""
+        raise NotImplementedError
+
+    # @abstractmethod
+    # @staticmethod
+    # def print_messages():
+    #     raise NotImplementedError
+
+    # @abstractmethod
+    # @staticmethod
+    # def print_messages_raw():
+    #     raise NotImplementedError
+
+    # @abstractmethod
+    # @staticmethod
+    # def step_yield():
+    #     raise NotImplementedError
+
+
+class CLIInterface(AgentInterface):
+    """Basic interface for dumping agent events to the command-line"""
+
+    @staticmethod
+    def important_message(msg: str):
+        fstr = f"{Fore.MAGENTA}{Style.BRIGHT}{{msg}}{Style.RESET_ALL}"
+        if STRIP_UI:
+            fstr = "{msg}"
+        print(fstr.format(msg=msg))
+
+    @staticmethod
+    def warning_message(msg: str):
+        fstr = f"{Fore.RED}{Style.BRIGHT}{{msg}}{Style.RESET_ALL}"
+        if STRIP_UI:
+            fstr = "{msg}"
+        else:
+            print(fstr.format(msg=msg))
+
+    @staticmethod
+    def internal_monologue(msg: str, msg_obj: Optional[Message] = None):
+        # ANSI escape code for italic is '\x1B[3m'
+        fstr = f"\x1B[3m{Fore.LIGHTBLACK_EX}💭 {{msg}}{Style.RESET_ALL}"
+        if STRIP_UI:
+            fstr = "{msg}"
+        print(fstr.format(msg=msg))
+
+    @staticmethod
+    def assistant_message(msg: str, msg_obj: Optional[Message] = None):
+        fstr = f"{Fore.YELLOW}{Style.BRIGHT}🤖 {Fore.YELLOW}{{msg}}{Style.RESET_ALL}"
+        if STRIP_UI:
+            fstr = "{msg}"
+        print(fstr.format(msg=msg))
+
+    @staticmethod
+    def memory_message(msg: str, msg_obj: Optional[Message] = None):
+        fstr = f"{Fore.LIGHTMAGENTA_EX}{Style.BRIGHT}🧠 {Fore.LIGHTMAGENTA_EX}{{msg}}{Style.RESET_ALL}"
+        if STRIP_UI:
+            fstr = "{msg}"
+        print(fstr.format(msg=msg))
+
+    @staticmethod
+    def system_message(msg: str, msg_obj: Optional[Message] = None):
+        fstr = f"{Fore.MAGENTA}{Style.BRIGHT}🖥️ [system] {Fore.MAGENTA}{msg}{Style.RESET_ALL}"
+        if STRIP_UI:
+            fstr = "{msg}"
+        print(fstr.format(msg=msg))
+
+    @staticmethod
+    def user_message(msg: str, msg_obj: Optional[Message] = None, raw: bool = False, dump: bool = False, debug: bool = DEBUG):
+        def print_user_message(icon, msg, printf=print):
+            if STRIP_UI:
+                printf(f"{icon} {msg}")
+            else:
+                printf(f"{Fore.GREEN}{Style.BRIGHT}{icon} {Fore.GREEN}{msg}{Style.RESET_ALL}")
+
+        def printd_user_message(icon, msg):
+            return print_user_message(icon, msg)
+
+        if not (raw or dump or debug):
+            # we do not want to repeat the message in normal use
+            return
+
+        if isinstance(msg, str):
+            if raw:
+                printd_user_message("🧑", msg)
+                return
+            else:
+                try:
+                    msg_json = json_loads(msg)
+                except:
+                    printd(f"{CLI_WARNING_PREFIX}failed to parse user message into json")
+                    printd_user_message("🧑", msg)
+                    return
+        if msg_json["type"] == "user_message":
+            if dump:
+                print_user_message("🧑", msg_json["message"])
+                return
+            msg_json.pop("type")
+            printd_user_message("🧑", msg_json)
+        elif msg_json["type"] == "heartbeat":
+            if debug:
+                msg_json.pop("type")
+                printd_user_message("💓", msg_json)
+            elif dump:
+                print_user_message("💓", msg_json)
+                return
+
+        elif msg_json["type"] == "system_message":
+            msg_json.pop("type")
+            printd_user_message("🖥️", msg_json)
+        else:
+            printd_user_message("🧑", msg_json)
+
+    @staticmethod
+    def function_message(msg: str, msg_obj: Optional[Message] = None, debug: bool = DEBUG):
+        def print_function_message(icon, msg, color=Fore.RED, printf=print):
+            if STRIP_UI:
+                printf(f"⚡{icon} [function] {msg}")
+            else:
+                printf(f"{color}{Style.BRIGHT}⚡{icon} [function] {color}{msg}{Style.RESET_ALL}")
+
+        def printd_function_message(icon, msg, color=Fore.RED):
+            return print_function_message(icon, msg, color, printf=(print if debug else printd))
+
+        if isinstance(msg, dict):
+            printd_function_message("", msg)
+            return
+
+        if msg.startswith("Success"):
+            printd_function_message("🟢", msg)
+        elif msg.startswith("Error: "):
+            printd_function_message("🔴", msg)
+        elif msg.startswith("Ran "):
+            # NOTE: ignore 'ran' messages that come post-execution
+            return
+        elif msg.startswith("Running "):
+            if debug:
+                printd_function_message("", msg)
+            else:
+                match = re.search(r"Running (\w+)\((.*)\)", msg)
+                if match:
+                    function_name = match.group(1)
+                    function_args = match.group(2)
+                    if function_name in ["archival_memory_insert", "archival_memory_search", "core_memory_replace", "core_memory_append"]:
+                        if function_name in ["archival_memory_insert", "core_memory_append", "core_memory_replace"]:
+                            print_function_message("🧠", f"updating memory with {function_name}")
+                        elif function_name == "archival_memory_search":
+                            print_function_message("🧠", f"searching memory with {function_name}")
+                        try:
+                            msg_dict = eval(function_args)
+                            if function_name == "archival_memory_search":
+                                output = f'\tquery: {msg_dict["query"]}, page: {msg_dict["page"]}'
+                                if STRIP_UI:
+                                    print(output)
+                                else:
+                                    print(f"{Fore.RED}{output}{Style.RESET_ALL}")
+                            elif function_name == "archival_memory_insert":
+                                output = f'\t→ {msg_dict["content"]}'
+                                if STRIP_UI:
+                                    print(output)
+                                else:
+                                    print(f"{Style.BRIGHT}{Fore.RED}{output}{Style.RESET_ALL}")
+                            else:
+                                if STRIP_UI:
+                                    print(f'\t {msg_dict["old_content"]}\n\t→ {msg_dict["new_content"]}')
+                                else:
+                                    print(
+                                        f'{Style.BRIGHT}\t{Fore.RED} {msg_dict["old_content"]}\n\t{Fore.GREEN}→ {msg_dict["new_content"]}{Style.RESET_ALL}'
+                                    )
+                        except Exception as e:
+                            printd(str(e))
+                            printd(msg_dict)
+                    elif function_name in ["conversation_search", "conversation_search_date"]:
+                        print_function_message("🧠", f"searching memory with {function_name}")
+                        try:
+                            msg_dict = eval(function_args)
+                            output = f'\tquery: {msg_dict["query"]}, page: {msg_dict["page"]}'
+                            if STRIP_UI:
+                                print(output)
+                            else:
+                                print(f"{Fore.RED}{output}{Style.RESET_ALL}")
+                        except Exception as e:
+                            printd(str(e))
+                            printd(msg_dict)
+                else:
+                    printd(f"{CLI_WARNING_PREFIX}did not recognize function message")
+                    printd_function_message("", msg)
+        else:
+            try:
+                msg_dict = json_loads(msg)
+                if "status" in msg_dict and msg_dict["status"] == "OK":
+                    printd_function_message("", str(msg), color=Fore.GREEN)
+                else:
+                    printd_function_message("", str(msg), color=Fore.RED)
+            except Exception:
+                print(f"{CLI_WARNING_PREFIX}did not recognize function message {type(msg)} {msg}")
+                printd_function_message("", msg)
+
+    @staticmethod
+    def print_messages(message_sequence: List[Message], dump=False):
+        # rewrite to dict format
+        message_sequence = [msg.to_openai_dict() for msg in message_sequence]
+
+        idx = len(message_sequence)
+        for msg in message_sequence:
+            if dump:
+                print(f"[{idx}] ", end="")
+                idx -= 1
+            role = msg["role"]
+            content = msg["content"]
+
+            if role == "system":
+                CLIInterface.system_message(content)
+            elif role == "assistant":
+                # Differentiate between internal monologue, function calls, and messages
+                if msg.get("function_call"):
+                    if content is not None:
+                        CLIInterface.internal_monologue(content)
+                    # I think the next one is not up to date
+                    # function_message(msg["function_call"])
+                    args = json_loads(msg["function_call"].get("arguments"))
+                    CLIInterface.assistant_message(args.get("message"))
+                    # assistant_message(content)
+                elif msg.get("tool_calls"):
+                    if content is not None:
+                        CLIInterface.internal_monologue(content)
+                    function_obj = msg["tool_calls"][0].get("function")
+                    if function_obj:
+                        args = json_loads(function_obj.get("arguments"))
+                        CLIInterface.assistant_message(args.get("message"))
+                else:
+                    CLIInterface.internal_monologue(content)
+            elif role == "user":
+                CLIInterface.user_message(content, dump=dump)
+            elif role == "function":
+                CLIInterface.function_message(content, debug=dump)
+            elif role == "tool":
+                CLIInterface.function_message(content, debug=dump)
+            else:
+                print(f"Unknown role: {content}")
+
+    @staticmethod
+    def print_messages_simple(message_sequence: List[Message]):
+        # rewrite to dict format
+        message_sequence = [msg.to_openai_dict() for msg in message_sequence]
+
+        for msg in message_sequence:
+            role = msg["role"]
+            content = msg["content"]
+
+            if role == "system":
+                CLIInterface.system_message(content)
+            elif role == "assistant":
+                CLIInterface.assistant_message(content)
+            elif role == "user":
+                CLIInterface.user_message(content, raw=True)
+            else:
+                print(f"Unknown role: {content}")
+
+    @staticmethod
+    def print_messages_raw(message_sequence: List[Message]):
+        # rewrite to dict format
+        message_sequence = [msg.to_openai_dict() for msg in message_sequence]
+
+        for msg in message_sequence:
+            print(msg)
+
+    @staticmethod
+    def step_yield():
+        pass
+
+    @staticmethod
+    def step_complete():
+        pass