letta-nightly 0.5.4.dev20241130104041__py3-none-any.whl → 0.5.4.dev20241201104110__py3-none-any.whl

letta/agent.py

@@ -1,5 +1,6 @@
 import datetime
 import inspect
+import time
 import traceback
 import warnings
 from abc import ABC, abstractmethod
@@ -566,60 +567,60 @@ class Agent(BaseAgent):
         self,
         message_sequence: List[Message],
         function_call: str = "auto",
-        first_message: bool = False,  # hint
+        first_message: bool = False,
         stream: bool = False,  # TODO move to config?
-        fail_on_empty_response: bool = False,
         empty_response_retry_limit: int = 3,
+        backoff_factor: float = 0.5,  # delay multiplier for exponential backoff
+        max_delay: float = 10.0,  # max delay between retries
     ) -> ChatCompletionResponse:
-        """Get response from LLM API"""
-        # Get the allowed tools based on the ToolRulesSolver state
+        """Get response from LLM API with robust retry mechanism."""
+
         allowed_tool_names = self.tool_rules_solver.get_allowed_tool_names()
+        allowed_functions = (
+            self.functions if not allowed_tool_names else [func for func in self.functions if func["name"] in allowed_tool_names]
+        )
 
-        if not allowed_tool_names:
-            # if it's empty, any available tools are fair game
-            allowed_functions = self.functions
-        else:
-            allowed_functions = [func for func in self.functions if func["name"] in allowed_tool_names]
+        for attempt in range(1, empty_response_retry_limit + 1):
+            try:
+                response = create(
+                    llm_config=self.agent_state.llm_config,
+                    messages=message_sequence,
+                    user_id=self.agent_state.user_id,
+                    functions=allowed_functions,
+                    functions_python=self.functions_python,
+                    function_call=function_call,
+                    first_message=first_message,
+                    stream=stream,
+                    stream_interface=self.interface,
+                )
 
-        try:
-            response = create(
-                # agent_state=self.agent_state,
-                llm_config=self.agent_state.llm_config,
-                messages=message_sequence,
-                user_id=self.agent_state.user_id,
-                functions=allowed_functions,
-                functions_python=self.functions_python,
-                function_call=function_call,
-                # hint
-                first_message=first_message,
-                # streaming
-                stream=stream,
-                stream_interface=self.interface,
-            )
+                # These bottom two are retryable
+                if len(response.choices) == 0 or response.choices[0] is None:
+                    raise ValueError(f"API call returned an empty message: {response}")
 
-            if len(response.choices) == 0 or response.choices[0] is None:
-                empty_api_err_message = f"API call didn't return a message: {response}"
-                if fail_on_empty_response or empty_response_retry_limit == 0:
-                    raise Exception(empty_api_err_message)
-                else:
-                    # Decrement retry limit and try again
-                    warnings.warn(empty_api_err_message)
-                    return self._get_ai_reply(
-                        message_sequence, function_call, first_message, stream, fail_on_empty_response, empty_response_retry_limit - 1
-                    )
+                if response.choices[0].finish_reason not in ["stop", "function_call", "tool_calls"]:
+                    if response.choices[0].finish_reason == "length":
+                        # This is not retryable, hence RuntimeError v.s. ValueError
+                        raise RuntimeError("Finish reason was length (maximum context length)")
+                    else:
+                        raise ValueError(f"Bad finish reason from API: {response.choices[0].finish_reason}")
+
+                return response
 
-            # special case for 'length'
-            if response.choices[0].finish_reason == "length":
-                raise Exception("Finish reason was length (maximum context length)")
+            except ValueError as ve:
+                if attempt >= empty_response_retry_limit:
+                    warnings.warn(f"Retry limit reached. Final error: {ve}")
+                    break
+                else:
+                    delay = min(backoff_factor * (2 ** (attempt - 1)), max_delay)
+                    warnings.warn(f"Attempt {attempt} failed: {ve}. Retrying in {delay} seconds...")
+                    time.sleep(delay)
 
-            # catches for soft errors
-            if response.choices[0].finish_reason not in ["stop", "function_call", "tool_calls"]:
-                raise Exception(f"API call finish with bad finish reason: {response}")
+            except Exception as e:
+                # For non-retryable errors, exit immediately
+                raise e
 
-            # unpack with response.choices[0].message.content
-            return response
-        except Exception as e:
-            raise e
+        raise Exception("Retries exhausted and no valid response received.")
 
     def _handle_ai_response(
         self,

letta/functions/functions.py

@@ -11,23 +11,54 @@ from letta.functions.schema_generator import generate_schema
 
 
 def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> dict:
-    # auto-generate openai schema
+    """Derives the OpenAI JSON schema for a given function source code.
+
+    First, attempts to execute the source code in a custom environment with only the necessary imports.
+    Then, it generates the schema from the function's docstring and signature.
+    """
     try:
         # Define a custom environment with necessary imports
-        env = {"Optional": Optional, "List": List, "Dict": Dict}  # Add any other required imports here
-
+        env = {
+            "Optional": Optional,
+            "List": List,
+            "Dict": Dict,
+            # To support Pydantic models
+            # "BaseModel": BaseModel,
+            # "Field": Field,
+        }
         env.update(globals())
+
+        # print("About to execute source code...")
         exec(source_code, env)
+        # print("Source code executed successfully")
 
-        # get available functions
-        functions = [f for f in env if callable(env[f])]
+        functions = [f for f in env if callable(env[f]) and not f.startswith("__")]
+        if not functions:
+            raise LettaToolCreateError("No callable functions found in source code")
 
-        # TODO: not sure if this always works
+        # print(f"Found functions: {functions}")
         func = env[functions[-1]]
-        json_schema = generate_schema(func, name=name)
-        return json_schema
+
+        if not hasattr(func, "__doc__") or not func.__doc__:
+            raise LettaToolCreateError(f"Function {func.__name__} missing docstring")
+
+        # print("About to generate schema...")
+        try:
+            schema = generate_schema(func, name=name)
+            # print("Schema generated successfully")
+            return schema
+        except TypeError as e:
+            raise LettaToolCreateError(f"Type error in schema generation: {str(e)}")
+        except ValueError as e:
+            raise LettaToolCreateError(f"Value error in schema generation: {str(e)}")
+        except Exception as e:
+            raise LettaToolCreateError(f"Unexpected error in schema generation: {str(e)}")
+
     except Exception as e:
-        raise LettaToolCreateError(f"Failed to derive JSON schema from source code: {e}")
+        import traceback
+
+        traceback.print_exc()
+        raise LettaToolCreateError(f"Schema generation failed: {str(e)}") from e
 
 
 def parse_source_code(func) -> str:

letta/functions/schema_generator.py

@@ -22,7 +22,7 @@ def optional_length(annotation):
         raise ValueError("The annotation is not an Optional type")
 
 
-def type_to_json_schema_type(py_type):
+def type_to_json_schema_type(py_type) -> dict:
     """
     Maps a Python type to a JSON schema type.
     Specifically handles typing.Optional and common Python types.
@@ -36,36 +36,87 @@ def type_to_json_schema_type(py_type):
         # Extract and map the inner type
         return type_to_json_schema_type(type_args[0])
 
+    # Handle Union types (except Optional which is handled above)
+    if get_origin(py_type) is Union:
+        # TODO support mapping Unions to anyOf
+        raise NotImplementedError("General Union types are not yet supported")
+
+    # Handle array types
+    origin = get_origin(py_type)
+    if py_type == list or origin in (list, List):
+        args = get_args(py_type)
+
+        if args and inspect.isclass(args[0]) and issubclass(args[0], BaseModel):
+            # If it's a list of Pydantic models, return an array with the model schema as items
+            return {
+                "type": "array",
+                "items": pydantic_model_to_json_schema(args[0]),
+            }
+
+        # Otherwise, recursively call the basic type checker
+        return {
+            "type": "array",
+            # get the type of the items in the list
+            "items": type_to_json_schema_type(args[0]),
+        }
+
+    # Handle object types
+    if py_type == dict or origin in (dict, Dict):
+        args = get_args(py_type)
+        if not args:
+            # Generic dict without type arguments
+            return {
+                "type": "object",
+                # "properties": {}
+            }
+        else:
+            raise ValueError(
+                f"Dictionary types {py_type} with nested type arguments are not supported (consider using a Pydantic model instead)"
+            )
+
+        # NOTE: the below code works for generic JSON schema parsing, but there's a problem with the key inference
+        #       when it comes to OpenAI function schema generation so it doesn't make sense to allow for dict[str, Any] type hints
+        # key_type, value_type = args
+
+        # # Ensure dict keys are strings
+        # # Otherwise there's no JSON schema equivalent
+        # if key_type != str:
+        #     raise ValueError("Dictionary keys must be strings for OpenAI function schema compatibility")
+
+        # # Handle value type to determine property schema
+        # value_schema = {}
+        # if inspect.isclass(value_type) and issubclass(value_type, BaseModel):
+        #     value_schema = pydantic_model_to_json_schema(value_type)
+        # else:
+        #     value_schema = type_to_json_schema_type(value_type)
+
+        # # NOTE: the problem lies here - the key is always "key_placeholder"
+        # return {"type": "object", "properties": {"key_placeholder": value_schema}}
+
+    # Handle direct Pydantic models
+    if inspect.isclass(py_type) and issubclass(py_type, BaseModel):
+        return pydantic_model_to_json_schema(py_type)
+
     # Mapping of Python types to JSON schema types
     type_map = {
         # Basic types
+        # Optional, Union, and collections are handled above ^
         int: "integer",
         str: "string",
         bool: "boolean",
         float: "number",
-        # Collections
-        List[str]: "array",
-        List[int]: "array",
-        list: "array",
-        tuple: "array",
-        set: "array",
-        # Dictionaries
-        dict: "object",
-        Dict[str, Any]: "object",
-        # Special types
         None: "null",
-        type(None): "null",
-        # Optional types
-        # Optional[str]: "string",  # NOTE: caught above ^
-        Union[str, None]: "string",
     }
     if py_type not in type_map:
         raise ValueError(f"Python type {py_type} has no corresponding JSON schema type - full map: {type_map}")
-
-    return type_map.get(py_type, "string")  # Default to "string" if type not in map
+    else:
+        return {"type": type_map[py_type]}
 
 
-def pydantic_model_to_open_ai(model):
+def pydantic_model_to_open_ai(model: Type[BaseModel]) -> dict:
+    """
+    Converts a Pydantic model as a singular arg to a JSON schema object for use in OpenAI function calling.
+    """
     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")}
@@ -80,7 +131,7 @@ def pydantic_model_to_open_ai(model):
         if docstring.short_description:
             schema["description"] = docstring.short_description
         else:
-            raise
+            raise ValueError(f"No description found in docstring or description field (model: {model}, docstring: {docstring})")
 
     return {
         "name": schema["title"],
@@ -89,6 +140,159 @@ def pydantic_model_to_open_ai(model):
     }
 
 
+def pydantic_model_to_json_schema(model: Type[BaseModel]) -> dict:
+    """
+    Converts a Pydantic model (as an arg that already is annotated) to a JSON schema object for use in OpenAI function calling.
+
+    An example of a Pydantic model as an arg:
+
+    class Step(BaseModel):
+        name: str = Field(
+            ...,
+            description="Name of the step.",
+        )
+        key: str = Field(
+            ...,
+            description="Unique identifier for the step.",
+        )
+        description: str = Field(
+            ...,
+            description="An exhaustic description of what this step is trying to achieve and accomplish.",
+        )
+
+    def create_task_plan(steps: list[Step]):
+        '''
+        Creates a task plan for the current task.
+
+        Args:
+            steps: List of steps to add to the task plan.
+        ...
+
+    Should result in:
+    {
+      "name": "create_task_plan",
+      "description": "Creates a task plan for the current task.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "steps": {  # <= this is the name of the arg
+            "type": "object",
+            "description": "List of steps to add to the task plan.",
+            "properties": {
+              "name": {
+                "type": "str",
+                "description": "Name of the step.",
+              },
+              "key": {
+                "type": "str",
+                "description": "Unique identifier for the step.",
+              },
+              "description": {
+                "type": "str",
+                "description": "An exhaustic description of what this step is trying to achieve and accomplish.",
+              },
+            },
+            "required": ["name", "key", "description"],
+          }
+        },
+        "required": ["steps"],
+      }
+    }
+
+    Specifically, the result of pydantic_model_to_json_schema(steps) (where `steps` is an instance of BaseModel) is:
+    {
+        "type": "object",
+        "properties": {
+            "name": {
+                "type": "str",
+                "description": "Name of the step."
+            },
+            "key": {
+                "type": "str",
+                "description": "Unique identifier for the step."
+            },
+            "description": {
+                "type": "str",
+                "description": "An exhaustic description of what this step is trying to achieve and accomplish."
+            },
+        },
+        "required": ["name", "key", "description"],
+    }
+    """
+    schema = model.model_json_schema()
+
+    def clean_property(prop: dict) -> dict:
+        """Clean up a property schema to match desired format"""
+
+        if "description" not in prop:
+            raise ValueError(f"Property {prop} lacks a 'description' key")
+
+        return {
+            "type": "string" if prop["type"] == "string" else prop["type"],
+            "description": prop["description"],
+        }
+
+    def resolve_ref(ref: str, schema: dict) -> dict:
+        """Resolve a $ref reference in the schema"""
+        if not ref.startswith("#/$defs/"):
+            raise ValueError(f"Unexpected reference format: {ref}")
+
+        model_name = ref.split("/")[-1]
+        if model_name not in schema.get("$defs", {}):
+            raise ValueError(f"Reference {model_name} not found in schema definitions")
+
+        return schema["$defs"][model_name]
+
+    def clean_schema(schema_part: dict, full_schema: dict) -> dict:
+        """Clean up a schema part, handling references and nested structures"""
+        # Handle $ref
+        if "$ref" in schema_part:
+            schema_part = resolve_ref(schema_part["$ref"], full_schema)
+
+        if "type" not in schema_part:
+            raise ValueError(f"Schema part lacks a 'type' key: {schema_part}")
+
+        # Handle array type
+        if schema_part["type"] == "array":
+            items_schema = schema_part["items"]
+            if "$ref" in items_schema:
+                items_schema = resolve_ref(items_schema["$ref"], full_schema)
+            return {"type": "array", "items": clean_schema(items_schema, full_schema), "description": schema_part.get("description", "")}
+
+        # Handle object type
+        if schema_part["type"] == "object":
+            if "properties" not in schema_part:
+                raise ValueError(f"Object schema lacks 'properties' key: {schema_part}")
+
+            properties = {}
+            for name, prop in schema_part["properties"].items():
+                if "items" in prop:  # Handle arrays
+                    if "description" not in prop:
+                        raise ValueError(f"Property {prop} lacks a 'description' key")
+                    properties[name] = {
+                        "type": "array",
+                        "items": clean_schema(prop["items"], full_schema),
+                        "description": prop["description"],
+                    }
+                else:
+                    properties[name] = clean_property(prop)
+
+            pydantic_model_schema_dict = {
+                "type": "object",
+                "properties": properties,
+                "required": schema_part.get("required", []),
+            }
+            if "description" in schema_part:
+                pydantic_model_schema_dict["description"] = schema_part["description"]
+
+            return pydantic_model_schema_dict
+
+        # Handle primitive types
+        return clean_property(schema_part)
+
+    return clean_schema(schema_part=schema, full_schema=schema)
+
+
 def generate_schema(function, name: Optional[str] = None, description: Optional[str] = None) -> dict:
     # Get the signature of the function
     sig = inspect.signature(function)
@@ -126,24 +330,60 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
         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)
+        # If the parameter is a pydantic model, we need to unpack the Pydantic model type into a JSON schema object
+        # if inspect.isclass(param.annotation) and issubclass(param.annotation, BaseModel):
+        if (
+            (inspect.isclass(param.annotation) or inspect.isclass(get_origin(param.annotation) or param.annotation))
+            and not get_origin(param.annotation)
+            and issubclass(param.annotation, BaseModel)
+        ):
+            # print("Generating schema for pydantic model:", param.annotation)
+            # Extract the properties from the pydantic model
+            schema["parameters"]["properties"][param.name] = pydantic_model_to_json_schema(param.annotation)
+            schema["parameters"]["properties"][param.name]["description"] = param_doc.description
+
+        # Otherwise, we convert the Python typing to JSON schema types
+        # NOTE: important - if a dict or list, the internal type can be a Pydantic model itself
+        #                   however in that
         else:
-            # Add parameter details to the schema
+            # print("Generating schema for non-pydantic model:", param.annotation)
+            # Grab the description for the parameter from the extended docstring
+            # If it doesn't exist, we should raise an error
             param_doc = next((d for d in docstring.params if d.arg_name == param.name), None)
-            if param_doc:
-                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:
+            if not param_doc:
+                raise ValueError(f"Parameter '{param.name}' in function '{function.__name__}' lacks a description in the docstring")
+            elif not isinstance(param_doc.description, str):
+                raise ValueError(
+                    f"Parameter '{param.name}' in function '{function.__name__}' has a description in the docstring that is not a string (type: {type(param_doc.description)})"
+                )
+            else:
+                # If it's a string or a basic type, then all you need is: (1) type, (2) description
+                # If it's a more complex type, then you also need either:
+                # - for array, you need "items", each of which has "type"
+                # - for a dict, you need "properties", which has keys which each have "type"
+                if param.annotation != inspect.Parameter.empty:
+                    param_generated_schema = type_to_json_schema_type(param.annotation)
+                else:
+                    # TODO why are we inferring here?
+                    param_generated_schema = {"type": "string"}
+
+                # Add in the description
+                param_generated_schema["description"] = param_doc.description
+
+                # Add the schema to the function arg key
+                schema["parameters"]["properties"][param.name] = param_generated_schema
+
+        # If the parameter doesn't have a default value, it is required (so we need to add it to the required list)
+        if param.default == inspect.Parameter.empty and not is_optional(param.annotation):
             schema["parameters"]["required"].append(param.name)
 
+        # TODO what's going on here?
+        # If the parameter is a list of strings we need to hard cast to "string" instead of `str`
         if get_origin(param.annotation) is list:
             if get_args(param.annotation)[0] is str:
                 schema["parameters"]["properties"][param.name]["items"] = {"type": "string"}
 
+        # TODO is this not duplicating the other append directly above?
         if param.annotation == inspect.Parameter.empty:
             schema["parameters"]["required"].append(param.name)
 

letta/llm_api/helpers.py

@@ -11,7 +11,55 @@ from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
 from letta.utils import json_dumps, printd
 
 
-def convert_to_structured_output(openai_function: dict) -> dict:
+def _convert_to_structured_output_helper(property: dict) -> dict:
+    """Convert a single JSON schema property to structured output format (recursive)"""
+
+    if "type" not in property:
+        raise ValueError(f"Property {property} is missing a type")
+    param_type = property["type"]
+
+    if "description" not in property:
+        # raise ValueError(f"Property {property} is missing a description")
+        param_description = None
+    else:
+        param_description = property["description"]
+
+    if param_type == "object":
+        if "properties" not in property:
+            raise ValueError(f"Property {property} of type object is missing properties")
+        properties = property["properties"]
+        property_dict = {
+            "type": "object",
+            "properties": {k: _convert_to_structured_output_helper(v) for k, v in properties.items()},
+            "additionalProperties": False,
+            "required": list(properties.keys()),
+        }
+        if param_description is not None:
+            property_dict["description"] = param_description
+        return property_dict
+
+    elif param_type == "array":
+        if "items" not in property:
+            raise ValueError(f"Property {property} of type array is missing items")
+        items = property["items"]
+        property_dict = {
+            "type": "array",
+            "items": _convert_to_structured_output_helper(items),
+        }
+        if param_description is not None:
+            property_dict["description"] = param_description
+        return property_dict
+
+    else:
+        property_dict = {
+            "type": param_type,  # simple type
+        }
+        if param_description is not None:
+            property_dict["description"] = param_description
+        return property_dict
+
+
+def convert_to_structured_output(openai_function: dict, allow_optional: bool = False) -> dict:
     """Convert function call objects to structured output objects
 
     See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas
@@ -22,17 +70,63 @@ def convert_to_structured_output(openai_function: dict) -> dict:
         "name": openai_function["name"],
         "description": description,
         "strict": True,
-        "parameters": {"type": "object", "properties": {}, "additionalProperties": False, "required": []},
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "additionalProperties": False,
+            "required": [],
+        },
     }
 
+    # This code needs to be able to handle nested properties
+    # For example, the param details may have "type" + "description",
+    # but if "type" is "object" we expected "properties", where each property has details
+    # and if "type" is "array" we expect "items": <type>
     for param, details in openai_function["parameters"]["properties"].items():
-        structured_output["parameters"]["properties"][param] = {"type": details["type"], "description": details["description"]}
+
+        param_type = details["type"]
+        description = details["description"]
+
+        if param_type == "object":
+            if "properties" not in details:
+                # Structured outputs requires the properties on dicts be specified ahead of time
+                raise ValueError(f"Property {param} of type object is missing properties")
+            structured_output["parameters"]["properties"][param] = {
+                "type": "object",
+                "description": description,
+                "properties": {k: _convert_to_structured_output_helper(v) for k, v in details["properties"].items()},
+                "additionalProperties": False,
+                "required": list(details["properties"].keys()),
+            }
+
+        elif param_type == "array":
+            structured_output["parameters"]["properties"][param] = {
+                "type": "array",
+                "description": description,
+                "items": _convert_to_structured_output_helper(details["items"]),
+            }
+
+        else:
+            structured_output["parameters"]["properties"][param] = {
+                "type": param_type,  # simple type
+                "description": description,
+            }
 
         if "enum" in details:
             structured_output["parameters"]["properties"][param]["enum"] = details["enum"]
 
-    # Add all properties to required list
-    structured_output["parameters"]["required"] = list(structured_output["parameters"]["properties"].keys())
+    if not allow_optional:
+        # Add all properties to required list
+        structured_output["parameters"]["required"] = list(structured_output["parameters"]["properties"].keys())
+
+    else:
+        # See what parameters exist that aren't required
+        # Those are implied "optional" types
+        # For those types, turn each of them into a union type with "null"
+        # e.g.
+        # "type": "string" -> "type": ["string", "null"]
+        # TODO
+        raise NotImplementedError
 
     return structured_output
 

letta/llm_api/openai.py

@@ -477,7 +477,10 @@ def openai_chat_completions_request_stream(
     if "tools" in data:
         for tool in data["tools"]:
             # tool["strict"] = True
-            tool["function"] = convert_to_structured_output(tool["function"])
+            try:
+                tool["function"] = convert_to_structured_output(tool["function"])
+            except ValueError as e:
+                warnings.warn(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
 
     # print(f"\n\n\n\nData[tools]: {json.dumps(data['tools'], indent=2)}")
 
@@ -533,7 +536,10 @@ def openai_chat_completions_request(
 
     if "tools" in data:
         for tool in data["tools"]:
-            tool["function"] = convert_to_structured_output(tool["function"])
+            try:
+                tool["function"] = convert_to_structured_output(tool["function"])
+            except ValueError as e:
+                warnings.warn(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
 
     response_json = make_post_request(url, headers, data)
     return ChatCompletionResponse(**response_json)

letta/local_llm/utils.py

@@ -121,7 +121,7 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
                                 function_tokens += 3
                                 function_tokens += len(encoding.encode(o))
                         else:
-                            print(f"Warning: not supported field {field}")
+                            warnings.warn(f"num_tokens_from_functions: Unsupported field {field} in function {function}")
                 function_tokens += 11
 
         num_tokens += function_tokens

letta/server/rest_api/app.py

@@ -134,7 +134,7 @@ def create_application() -> "FastAPI":
 
     if "--ade" in sys.argv:
         settings.cors_origins.append("https://app.letta.com")
-        print(f"▶ View using ADE at: https://app.letta.com/local-project/agents")
+        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
 
     if "--secure" in sys.argv:
         print(f"▶ Using secure mode with password: {random_password}")

letta/services/tool_execution_sandbox.py

@@ -276,6 +276,25 @@ class ToolExecutionSandbox:
 
         return code
 
+    def _convert_param_to_value(self, param_type: str, raw_value: str) -> str:
+
+        if param_type == "string":
+            value = '"' + raw_value + '"'
+
+        elif param_type == "integer" or param_type == "boolean" or param_type == "number":
+            value = raw_value
+
+        elif param_type == "array":
+            value = raw_value
+
+        elif param_type == "object":
+            value = raw_value
+
+        else:
+            raise TypeError(f"Unsupported type: {param_type}, raw_value={raw_value}")
+
+        return str(value)
+
     def initialize_param(self, name: str, raw_value: str) -> str:
         params = self.tool.json_schema["parameters"]["properties"]
         spec = params.get(name)
@@ -287,14 +306,9 @@ class ToolExecutionSandbox:
         if param_type is None and spec.get("parameters"):
             param_type = spec["parameters"].get("type")
 
-        if param_type == "string":
-            value = '"' + raw_value + '"'
-        elif param_type == "integer" or param_type == "boolean":
-            value = raw_value
-        else:
-            raise TypeError(f"unsupported type: {param_type}")
+        value = self._convert_param_to_value(param_type, raw_value)
 
-        return name + " = " + str(value) + "\n"
+        return name + " = " + value + "\n"
 
     def invoke_function_call(self, inject_agent_state: bool) -> str:
         """

{letta_nightly-0.5.4.dev20241130104041.dist-info → letta_nightly-0.5.4.dev20241201104110.dist-info}/METADATA

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

{letta_nightly-0.5.4.dev20241130104041.dist-info → letta_nightly-0.5.4.dev20241201104110.dist-info}/RECORD

@@ -1,6 +1,6 @@
 letta/__init__.py,sha256=FGDVS-TIQ5GQN2d3DaYbDaEaDCH54TpwzX5lSn60KwY,1035
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=-4L2daggVPMjZylLFbilfcpzmjfrSQXHFpqbRmqPQRs,77352
+letta/agent.py,sha256=9M0emIYjOlE3ZlJJYReDYZO84Atnd1ds7Je5KOEYcjE,77519
 letta/agent_store/chroma.py,sha256=-kCEMBFKmqCyFeIETYf7RN-khGddsip2FAhSzNqaC7U,12537
 letta/agent_store/db.py,sha256=n15t8qhHfqhtFDxSQg_9uwvMntpWml8Jz_Y-ofL0loQ,23467
 letta/agent_store/lancedb.py,sha256=i63d4VZwj9UIOTNs5f0JZ_r5yZD-jKWz4FAH4RMpXOE,5104
@@ -26,9 +26,9 @@ letta/errors.py,sha256=mFeTpZP37otDMr68s9hyGOnafJPrWeblQOI79cgP4nQ,3209
 letta/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/functions/function_sets/base.py,sha256=9Rs8SNrtUgqYtlmztE1gVO6FEn864u8t-X1qik24nps,8096
 letta/functions/function_sets/extras.py,sha256=Jik3UiDqYTm4Lam1XPTvuVjvgUHwIAhopsnbmVhGMBg,4732
-letta/functions/functions.py,sha256=7FankCCKpUgBUnrzmF96sRy8fHyfkfYFFJ_f45MsZh0,4196
+letta/functions/functions.py,sha256=qCoU9w51uXC8NODHr6dj_tz69NB4924I9PToN2yh2NA,5418
 letta/functions/helpers.py,sha256=K84kqAN1RXZIhjb7-btS0C2p-SInYNv6FvSfo-16Y6g,8578
-letta/functions/schema_generator.py,sha256=PIuey3ZsMvOTBViPWlqajleu48LOEEkcxnLhRPkyRsE,9076
+letta/functions/schema_generator.py,sha256=Y0rQjJBI8Z5fSKmT71EGXtHpIvNb3dMM5X00TP89tlY,19330
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
 letta/helpers/tool_rule_solver.py,sha256=YCwawbRUQw10ZVR17WYXo8b5roxdGe-B5nNVMqlAgBE,4826
 letta/humans/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -41,10 +41,10 @@ letta/llm_api/azure_openai.py,sha256=Y1HKPog1XzM_f7ujUK_Gv2zQkoy5pU-1bKiUnvSxSrs
 letta/llm_api/azure_openai_constants.py,sha256=oXtKrgBFHf744gyt5l1thILXgyi8NDNUrKEa2GGGpjw,278
 letta/llm_api/cohere.py,sha256=vDRd-SUGp1t_JUIdwC3RkIhwMl0OY7n-tAU9uPORYkY,14826
 letta/llm_api/google_ai.py,sha256=xKz9JDZs3m6yzSfcgCAAUD_rjI20BBIINoiSvlcnOw0,17621
-letta/llm_api/helpers.py,sha256=KqkdjZWYghx4OPwLcHEC6ruc_z9DScbysw3VH4x9A0Q,9887
+letta/llm_api/helpers.py,sha256=F8xZDZgDojWX5v-0vakyeUQyCyBr1HmzmsITRdOsmVg,13457
 letta/llm_api/llm_api_tools.py,sha256=h2eudFygI6yFIOaA5Q9GmhiwMPq2mHQyhoSHbn57CCE,16866
 letta/llm_api/mistral.py,sha256=fHdfD9ug-rQIk2qn8tRKay1U6w9maF11ryhKi91FfXM,1593
-letta/llm_api/openai.py,sha256=gGuxfE4_TURwnKfleogDCURvKe4UFb7KitoCWqWqKkI,23844
+letta/llm_api/openai.py,sha256=Z3xNoJPtplzNU5Lj8JkQg8lJkSb18QKIpFTfLRoaK5E,24180
 letta/local_llm/README.md,sha256=hFJyw5B0TU2jrh9nb0zGZMgdH-Ei1dSRfhvPQG_NSoU,168
 letta/local_llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/local_llm/chat_completion_proxy.py,sha256=SiohxsjGTku4vOryOZx7I0t0xoO_sUuhXgoe62fKq3c,12995
@@ -76,7 +76,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=ZAbzDpu2WsBXjVGXJ-TKUpS99VTI__3EoZml9KqYef0,2971
 letta/local_llm/settings/simple.py,sha256=HAO2jBJ_hJCEsXWIJcD0sckR0tI0zs3x2CPdf6ORQLs,719
-letta/local_llm/utils.py,sha256=0DELikgq82aztlN-sAOSuDLWbG0IVD67P7kHHjJ6nF0,13101
+letta/local_llm/utils.py,sha256=4nS5I2PpUm20QK4E-fgamEUaDXJsvxpCPIOCr-PVB0M,13148
 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
@@ -164,7 +164,7 @@ letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/generate_openapi_schema.sh,sha256=0OtBhkC1g6CobVmNEd_m2B6sTdppjbJLXaM95icejvE,371
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/server/rest_api/app.py,sha256=QbCgYeyzA86iefwomROBAaxwvSWYQT10fhHcNZsyjH4,7555
+letta/server/rest_api/app.py,sha256=U5plRL_-doYlHSv071DeUl3GNA1UsLWsVaEfGrLKZUU,7570
 letta/server/rest_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/auth/index.py,sha256=fQBGyVylGSRfEMLQ17cZzrHd5Y1xiVylvPqH5Rl-lXQ,1378
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
@@ -211,7 +211,7 @@ letta/services/organization_manager.py,sha256=OfE2_NMmhqXURX4sg7hCOiFQVQpV5ZiPu7
 letta/services/per_agent_lock_manager.py,sha256=02iw5e-xoLiKGqqn2KdJdk-QlrDHPz5oMuEs1ibwXHA,540
 letta/services/sandbox_config_manager.py,sha256=9BCu59nHR4nIMFXgFyEMOY2UTmZvBMS3GlDBWWCHB4I,12648
 letta/services/source_manager.py,sha256=StX5Wfd7XSCKJet8qExIu3GMoI-eMIbEarAeTv2gq0s,6555
-letta/services/tool_execution_sandbox.py,sha256=VHsdRYYWkp5UQOzqmznsIOIXn7iUiXRGxNqv655YXwU,13100
+letta/services/tool_execution_sandbox.py,sha256=y14mlb8r3mppAb5l977t0zy2ywCCjOboFuqSvT41X1M,13457
 letta/services/tool_manager.py,sha256=FVCB9R3NFahh-KE5jROzf6J9WEgqhqGoDk5RpWjlgjg,7835
 letta/services/tool_sandbox_env/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/user_manager.py,sha256=UJa0hqCjz0yXtvrCR8OVBqlSR5lC_Ejn-uG__58zLds,4398
@@ -220,8 +220,8 @@ letta/streaming_interface.py,sha256=_FPUWy58j50evHcpXyd7zB1wWqeCc71NCFeWh_TBvnw,
 letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
 letta/utils.py,sha256=COwQLAt02eEM9tjp6p5kN8YeTqGXr714l5BvffLVCLU,32376
-letta_nightly-0.5.4.dev20241130104041.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.5.4.dev20241130104041.dist-info/METADATA,sha256=6eKk3xGkeaLXojj7YcGYym-Z1FiX9G34GeZmFgT4wf8,11515
-letta_nightly-0.5.4.dev20241130104041.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.5.4.dev20241130104041.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.5.4.dev20241130104041.dist-info/RECORD,,
+letta_nightly-0.5.4.dev20241201104110.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.5.4.dev20241201104110.dist-info/METADATA,sha256=5QfUql5hNMn_8aOPuyG3cVU4Gm8JcVX8GFdrM1DBPkI,11515
+letta_nightly-0.5.4.dev20241201104110.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.5.4.dev20241201104110.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.5.4.dev20241201104110.dist-info/RECORD,,