letta-nightly 0.5.4.dev20241128000451__py3-none-any.whl → 0.6.0.dev20241204051808__py3-none-any.whl

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

@@ -88,7 +88,9 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
     try:
         encoding = tiktoken.encoding_for_model(model)
     except KeyError:
-        warnings.warn("Warning: model not found. Using cl100k_base encoding.")
+        from letta.utils import printd
+
+        printd(f"Warning: model not found. Using cl100k_base encoding.")
         encoding = tiktoken.get_encoding("cl100k_base")
 
     num_tokens = 0
@@ -121,7 +123,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
@@ -215,8 +217,10 @@ def num_tokens_from_messages(messages: List[dict], model: str = "gpt-4") -> int:
         # print("Warning: gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.")
         return num_tokens_from_messages(messages, model="gpt-4-0613")
     else:
-        warnings.warn(
-            f"""num_tokens_from_messages() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
+        from letta.utils import printd
+
+        printd(
+            f"num_tokens_from_messages() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."
         )
         return num_tokens_from_messages(messages, model="gpt-4-0613")
         # raise NotImplementedError(

letta/metadata.py

@@ -2,7 +2,6 @@
 
 import os
 import secrets
-import warnings
 from typing import List, Optional, Union
 
 from sqlalchemy import JSON, Column, DateTime, Index, String, TypeDecorator
@@ -359,8 +358,8 @@ class MetadataStore:
             #    warnings.warn(f"Agent {agent.id} has no _internal_memory field")
             if "tags" in fields:
                 del fields["tags"]
-            else:
-                warnings.warn(f"Agent {agent.id} has no tags field")
+            # else:
+            # warnings.warn(f"Agent {agent.id} has no tags field")
             session.add(AgentModel(**fields))
             session.commit()
 
@@ -376,8 +375,8 @@ class MetadataStore:
             #    warnings.warn(f"Agent {agent.id} has no _internal_memory field")
             if "tags" in fields:
                 del fields["tags"]
-            else:
-                warnings.warn(f"Agent {agent.id} has no tags field")
+            # else:
+            # warnings.warn(f"Agent {agent.id} has no tags field")
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 

letta/schemas/block.py

@@ -3,6 +3,7 @@ from typing import Optional
 from pydantic import BaseModel, Field, model_validator
 from typing_extensions import Self
 
+from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.schemas.letta_base import LettaBase
 
 # block of the LLM context
@@ -15,7 +16,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
 
     # data value
     value: str = Field(..., description="Value of the block.")
-    limit: int = Field(2000, description="Character limit of the block.")
+    limit: int = Field(CORE_MEMORY_BLOCK_CHAR_LIMIT, description="Character limit of the block.")
 
     # template data (optional)
     template_name: Optional[str] = Field(None, description="Name of the block if it is a template.", alias="name")
@@ -117,7 +118,7 @@ class BlockLabelUpdate(BaseModel):
 class BlockUpdate(BaseBlock):
     """Update a block"""
 
-    limit: Optional[int] = Field(2000, description="Character limit of the block.")
+    limit: Optional[int] = Field(CORE_MEMORY_BLOCK_CHAR_LIMIT, description="Character limit of the block.")
     value: Optional[str] = Field(None, description="Value of the block.")
 
     class Config:
@@ -147,7 +148,7 @@ class CreateBlock(BaseBlock):
     """Create a block"""
 
     label: str = Field(..., description="Label of the block.")
-    limit: int = Field(2000, description="Character limit of the block.")
+    limit: int = Field(CORE_MEMORY_BLOCK_CHAR_LIMIT, description="Character limit of the block.")
     value: str = Field(..., description="Value of the block.")
 
     # block templates

letta/schemas/tool.py

@@ -201,3 +201,15 @@ class ToolUpdate(LettaBase):
     class Config:
         extra = "ignore"  # Allows extra fields without validation errors
         # TODO: Remove this, and clean usage of ToolUpdate everywhere else
+
+
+class ToolRun(LettaBase):
+    id: str = Field(..., description="The ID of the tool to run.")
+    args: str = Field(..., description="The arguments to pass to the tool (as stringified JSON).")
+
+
+class ToolRunFromSource(LettaBase):
+    source_code: str = Field(..., description="The source code of the function.")
+    args: str = Field(..., description="The arguments to pass to the tool (as stringified JSON).")
+    name: Optional[str] = Field(None, description="The name of the tool to run.")
+    source_type: Optional[str] = Field(None, description="The type of the source code.")

letta/server/rest_api/app.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import os
 import sys
 from pathlib import Path
 from typing import Optional
@@ -103,7 +104,7 @@ def generate_password():
     return secrets.token_urlsafe(16)
 
 
-random_password = generate_password()
+random_password = os.getenv("LETTA_SERVER_PASSWORD") or generate_password()
 
 
 class CheckPasswordMiddleware(BaseHTTPMiddleware):
@@ -132,11 +133,11 @@ def create_application() -> "FastAPI":
         debug=True,
     )
 
-    if "--ade" in sys.argv:
+    if (os.getenv("LETTA_SERVER_ADE") == "true") or "--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:
+    if (os.getenv("LETTA_SERVER_SECURE") == "true") or "--secure" in sys.argv:
         print(f"▶ Using secure mode with password: {random_password}")
         app.add_middleware(CheckPasswordMiddleware)
 

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

@@ -448,21 +448,18 @@ async def send_message(
     This endpoint accepts a message from a user and processes it through the agent.
     """
     actor = server.get_user_or_default(user_id=user_id)
-
-    agent_lock = server.per_agent_lock_manager.get_lock(agent_id)
-    async with agent_lock:
-        result = await send_message_to_agent(
-            server=server,
-            agent_id=agent_id,
-            user_id=actor.id,
-            messages=request.messages,
-            stream_steps=False,
-            stream_tokens=False,
-            # Support for AssistantMessage
-            assistant_message_tool_name=request.assistant_message_tool_name,
-            assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
-        )
-        return result
+    result = await send_message_to_agent(
+        server=server,
+        agent_id=agent_id,
+        user_id=actor.id,
+        messages=request.messages,
+        stream_steps=False,
+        stream_tokens=False,
+        # Support for AssistantMessage
+        assistant_message_tool_name=request.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+    )
+    return result
 
 
 @router.post(
@@ -490,21 +487,18 @@ async def send_message_streaming(
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
     actor = server.get_user_or_default(user_id=user_id)
-
-    agent_lock = server.per_agent_lock_manager.get_lock(agent_id)
-    async with agent_lock:
-        result = await send_message_to_agent(
-            server=server,
-            agent_id=agent_id,
-            user_id=actor.id,
-            messages=request.messages,
-            stream_steps=True,
-            stream_tokens=request.stream_tokens,
-            # Support for AssistantMessage
-            assistant_message_tool_name=request.assistant_message_tool_name,
-            assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
-        )
-        return result
+    result = await send_message_to_agent(
+        server=server,
+        agent_id=agent_id,
+        user_id=actor.id,
+        messages=request.messages,
+        stream_steps=True,
+        stream_tokens=request.stream_tokens,
+        # Support for AssistantMessage
+        assistant_message_tool_name=request.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+    )
+    return result
 
 
 # TODO: move this into server.py?

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

@@ -8,6 +8,7 @@ from letta.schemas.sandbox_config import SandboxEnvironmentVariable as PydanticE
 from letta.schemas.sandbox_config import (
     SandboxEnvironmentVariableCreate,
     SandboxEnvironmentVariableUpdate,
+    SandboxType,
 )
 from letta.server.rest_api.utils import get_letta_server, get_user_id
 from letta.server.server import SyncServer
@@ -29,6 +30,24 @@ def create_sandbox_config(
     return server.sandbox_config_manager.create_or_update_sandbox_config(config_create, actor)
 
 
+@router.post("/e2b/default", response_model=PydanticSandboxConfig)
+def create_default_e2b_sandbox_config(
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.E2B, actor=actor)
+
+
+@router.post("/local/default", response_model=PydanticSandboxConfig)
+def create_default_local_sandbox_config(
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=actor)
+
+
 @router.patch("/{sandbox_config_id}", response_model=PydanticSandboxConfig)
 def update_sandbox_config(
     sandbox_config_id: str,

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

@@ -37,7 +37,10 @@ def get_source(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    return server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
+    source = server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
+    if not source:
+        raise HTTPException(status_code=404, detail=f"Source with id={source_id} not found.")
+    return source
 
 
 @router.get("/name/{source_name}", response_model=str, operation_id="get_source_id_by_name")
@@ -52,6 +55,8 @@ def get_source_id_by_name(
     actor = server.get_user_or_default(user_id=user_id)
 
     source = server.source_manager.get_source_by_name(source_name=source_name, actor=actor)
+    if not source:
+        raise HTTPException(status_code=404, detail=f"Source with name={source_name} not found.")
     return source.id
 
 
@@ -94,6 +99,8 @@ def update_source(
     Update the name or documentation of an existing data source.
     """
     actor = server.get_user_or_default(user_id=user_id)
+    if not server.source_manager.get_source_by_id(source_id=source_id, actor=actor):
+        raise HTTPException(status_code=404, detail=f"Source with id={source_id} does not exist.")
     return server.source_manager.update_source(source_id=source_id, source_update=source, actor=actor)
 
 

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

@@ -1,10 +1,12 @@
 from typing import List, Optional
 
+from composio.client.collections import ActionModel, AppModel
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
 from letta.errors import LettaToolCreateError
 from letta.orm.errors import UniqueConstraintViolationError
-from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
+from letta.schemas.letta_message import FunctionReturn
+from letta.schemas.tool import Tool, ToolCreate, ToolRunFromSource, ToolUpdate
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 
@@ -156,3 +158,88 @@ def add_base_tools(
     """
     actor = server.get_user_or_default(user_id=user_id)
     return server.tool_manager.add_base_tools(actor=actor)
+
+
+# NOTE: can re-enable if needed
+# @router.post("/{tool_id}/run", response_model=FunctionReturn, operation_id="run_tool")
+# def run_tool(
+#     server: SyncServer = Depends(get_letta_server),
+#     request: ToolRun = Body(...),
+#     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+# ):
+#     """
+#     Run an existing tool on provided arguments
+#     """
+#     actor = server.get_user_or_default(user_id=user_id)
+
+#     return server.run_tool(tool_id=request.tool_id, tool_args=request.tool_args, user_id=actor.id)
+
+
+@router.post("/run", response_model=FunctionReturn, operation_id="run_tool_from_source")
+def run_tool_from_source(
+    server: SyncServer = Depends(get_letta_server),
+    request: ToolRunFromSource = Body(...),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Attempt to build a tool from source, then run it on the provided arguments
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    try:
+        return server.run_tool_from_source(
+            tool_source=request.source_code,
+            tool_source_type=request.source_type,
+            tool_args=request.args,
+            tool_name=request.name,
+            user_id=actor.id,
+        )
+    except LettaToolCreateError as e:
+        # HTTP 400 == Bad Request
+        print(f"Error occurred during tool creation: {e}")
+        # print the full stack trace
+        import traceback
+
+        print(traceback.format_exc())
+        raise HTTPException(status_code=400, detail=str(e))
+
+    except Exception as e:
+        # Catch other unexpected errors and raise an internal server error
+        print(f"Unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+
+
+# Specific routes for Composio
+
+
+@router.get("/composio/apps", response_model=List[AppModel], operation_id="list_composio_apps")
+def list_composio_apps(server: SyncServer = Depends(get_letta_server)):
+    """
+    Get a list of all Composio apps
+    """
+    return server.get_composio_apps()
+
+
+@router.get("/composio/apps/{composio_app_name}/actions", response_model=List[ActionModel], operation_id="list_composio_actions_by_app")
+def list_composio_actions_by_app(
+    composio_app_name: str,
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Get a list of all Composio actions for a specific app
+    """
+    return server.get_composio_actions_from_app_name(composio_app_name=composio_app_name)
+
+
+@router.post("/composio/{composio_action_name}", response_model=Tool, operation_id="add_composio_tool")
+def add_composio_tool(
+    composio_action_name: str,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Add a new Composio tool by action name (Composio refers to each tool as an `Action`)
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+    tool_create = ToolCreate.from_composio(action=composio_action_name)
+    return server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=actor)