letta-nightly 0.5.5.dev20241122170833__py3-none-any.whl → 0.6.0.dev20241204051808__py3-none-any.whl

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

@@ -1,9 +1,12 @@
 from typing import List, Optional
 
+from composio.client.collections import ActionModel, AppModel
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
-from letta.orm.errors import NoResultFound
-from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
+from letta.errors import LettaToolCreateError
+from letta.orm.errors import UniqueConstraintViolationError
+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
 
@@ -14,12 +17,13 @@ router = APIRouter(prefix="/tools", tags=["tools"])
 def delete_tool(
     tool_id: str,
     server: SyncServer = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Delete a tool by name
     """
-    # actor = server.get_user_or_default(user_id=user_id)
-    server.tool_manager.delete_tool(tool_id=tool_id)
+    actor = server.get_user_or_default(user_id=user_id)
+    server.tool_manager.delete_tool_by_id(tool_id=tool_id, actor=actor)
 
 
 @router.get("/{tool_id}", response_model=Tool, operation_id="get_tool")
@@ -49,11 +53,10 @@ def get_tool_id(
     Get a tool ID by name
     """
     actor = server.get_user_or_default(user_id=user_id)
-
-    try:
-        tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+    tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+    if tool:
         return tool.id
-    except NoResultFound:
+    else:
         raise HTTPException(status_code=404, detail=f"Tool with name {tool_name} and organization id {actor.organization_id} not found.")
 
 
@@ -85,12 +88,50 @@ def create_tool(
     """
     Create a new tool
     """
-    # Derive user and org id from actor
-    actor = server.get_user_or_default(user_id=user_id)
+    try:
+        actor = server.get_user_or_default(user_id=user_id)
+        tool = Tool(**request.model_dump())
+        return server.tool_manager.create_tool(pydantic_tool=tool, actor=actor)
+    except UniqueConstraintViolationError as e:
+        # Log or print the full exception here for debugging
+        print(f"Error occurred: {e}")
+        clean_error_message = f"Tool with name {request.name} already exists."
+        raise HTTPException(status_code=409, detail=clean_error_message)
+    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)}")
 
-    # Send request to create the tool
-    tool = Tool(**request.model_dump())
-    return server.tool_manager.create_or_update_tool(pydantic_tool=tool, actor=actor)
+
+@router.put("/", response_model=Tool, operation_id="upsert_tool")
+def upsert_tool(
+    request: ToolCreate = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Create or update a tool
+    """
+    try:
+        actor = server.get_user_or_default(user_id=user_id)
+        tool = server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**request.model_dump()), actor=actor)
+        return tool
+    except UniqueConstraintViolationError as e:
+        # Log the error and raise a conflict exception
+        print(f"Unique constraint violation occurred: {e}")
+        raise HTTPException(status_code=409, 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)}")
 
 
 @router.patch("/{tool_id}", response_model=Tool, operation_id="update_tool")
@@ -117,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)

letta/server/rest_api/utils.py

@@ -5,6 +5,7 @@ import warnings
 from enum import Enum
 from typing import AsyncGenerator, Optional, Union
 
+from fastapi import Header
 from pydantic import BaseModel
 
 from letta.schemas.usage import LettaUsageStatistics
@@ -84,5 +85,10 @@ def get_letta_server() -> SyncServer:
     return server
 
 
+# Dependency to get user_id from headers
+def get_user_id(user_id: Optional[str] = Header(None, alias="user_id")) -> Optional[str]:
+    return user_id
+
+
 def get_current_interface() -> StreamingServerInterface:
     return StreamingServerInterface