letta-nightly 0.5.0.dev20241015014828__py3-none-any.whl → 0.5.0.dev20241016104103__py3-none-any.whl

letta/client/utils.py

@@ -1,6 +1,9 @@
+import re
 from datetime import datetime
+from typing import Optional
 
 from IPython.display import HTML, display
+from sqlalchemy.testing.plugin.plugin_base import warnings
 
 from letta.local_llm.constants import (
     ASSISTANT_MESSAGE_CLI_SYMBOL,
@@ -64,3 +67,15 @@ def pprint(messages):
     html_content += "</div>"
 
     display(HTML(html_content))
+
+
+def derive_function_name_regex(function_string: str) -> Optional[str]:
+    # Regular expression to match the function name
+    match = re.search(r"def\s+([a-zA-Z_]\w*)\s*\(", function_string)
+
+    if match:
+        function_name = match.group(1)
+        return function_name
+    else:
+        warnings.warn("No function name found.")
+        return None

letta/constants.py

@@ -39,7 +39,7 @@ DEFAULT_PRESET = "memgpt_chat"
 # Tools
 BASE_TOOLS = [
     "send_message",
-    "pause_heartbeats",
+    # "pause_heartbeats",
     "conversation_search",
     "conversation_search_date",
     "archival_memory_insert",

letta/functions/functions.py

@@ -27,7 +27,7 @@ def load_function_set(module: ModuleType) -> dict:
             if attr_name in function_dict:
                 raise ValueError(f"Found a duplicate of function name '{attr_name}'")
 
-            generated_schema = generate_schema(attr)
+            generated_schema = generate_schema(attr, terminal=False)
             function_dict[attr_name] = {
                 "module": inspect.getsource(module),
                 "python_function": attr,

letta/functions/schema_generator.py

@@ -74,7 +74,7 @@ def pydantic_model_to_open_ai(model):
     }
 
 
-def generate_schema(function, name: Optional[str] = None, description: Optional[str] = None):
+def generate_schema(function, terminal: Optional[bool], name: Optional[str] = None, description: Optional[str] = None):
     # Get the signature of the function
     sig = inspect.signature(function)
 
@@ -127,7 +127,8 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
             schema["parameters"]["required"].append(param.name)
 
     # append the heartbeat
-    if function.__name__ not in ["send_message", "pause_heartbeats"]:
+    # TODO: don't hard-code
+    if function.__name__ not in ["send_message", "pause_heartbeats"] and not terminal:
         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.",

letta/main.py

@@ -361,8 +361,10 @@ def run_agent_loop(
         skip_next_user_input = False
 
         def process_agent_step(user_message, no_verify):
+            # TODO(charles): update to use agent.step() instead of inner_step()
+
             if user_message is None:
-                step_response = letta_agent.step(
+                step_response = letta_agent.inner_step(
                     messages=[],
                     first_message=False,
                     skip_verify=no_verify,
@@ -402,15 +404,15 @@ def run_agent_loop(
         while True:
             try:
                 if strip_ui:
-                    new_messages, user_message, skip_next_user_input = process_agent_step(user_message, no_verify)
+                    _, user_message, skip_next_user_input = process_agent_step(user_message, no_verify)
                     break
                 else:
                     if stream:
                         # Don't display the "Thinking..." if streaming
-                        new_messages, user_message, skip_next_user_input = process_agent_step(user_message, no_verify)
+                        _, user_message, skip_next_user_input = process_agent_step(user_message, no_verify)
                     else:
                         with console.status("[bold cyan]Thinking...") as status:
-                            new_messages, user_message, skip_next_user_input = process_agent_step(user_message, no_verify)
+                            _, user_message, skip_next_user_input = process_agent_step(user_message, no_verify)
                     break
             except KeyboardInterrupt:
                 print("User interrupt occurred.")

letta/metadata.py

@@ -577,7 +577,7 @@ class MetadataStore:
     @enforce_types
     def create_tool(self, tool: Tool):
         with self.session_maker() as session:
-            if self.get_tool(tool_name=tool.name, user_id=tool.user_id) is not None:
+            if self.get_tool(tool_id=tool.id, tool_name=tool.name, user_id=tool.user_id) is not None:
                 raise ValueError(f"Tool with name {tool.name} already exists")
             session.add(ToolModel(**vars(tool)))
             session.commit()
@@ -620,9 +620,9 @@ class MetadataStore:
             session.commit()
 
     @enforce_types
-    def update_tool(self, tool: Tool):
+    def update_tool(self, tool_id: str, tool: Tool):
         with self.session_maker() as session:
-            session.query(ToolModel).filter(ToolModel.id == tool.id).update(vars(tool))
+            session.query(ToolModel).filter(ToolModel.id == tool_id).update(vars(tool))
             session.commit()
 
     @enforce_types
@@ -631,6 +631,21 @@ class MetadataStore:
             session.query(ToolModel).filter(ToolModel.id == tool_id).delete()
             session.commit()
 
+    @enforce_types
+    def delete_file_from_source(self, source_id: str, file_id: str, user_id: Optional[str]):
+        with self.session_maker() as session:
+            file_metadata = (
+                session.query(FileMetadataModel)
+                .filter(FileMetadataModel.source_id == source_id, FileMetadataModel.id == file_id, FileMetadataModel.user_id == user_id)
+                .first()
+            )
+
+            if file_metadata:
+                session.delete(file_metadata)
+                session.commit()
+
+            return file_metadata
+
     @enforce_types
     def delete_block(self, block_id: str):
         with self.session_maker() as session:
@@ -800,6 +815,15 @@ class MetadataStore:
                 results = session.query(ToolModel).filter(ToolModel.name == tool_name).filter(ToolModel.user_id == None).all()
                 if user_id:
                     results += session.query(ToolModel).filter(ToolModel.name == tool_name).filter(ToolModel.user_id == user_id).all()
+            if len(results) == 0:
+                return None
+            # assert len(results) == 1, f"Expected 1 result, got {len(results)}"
+            return results[0].to_record()
+
+    @enforce_types
+    def get_tool_with_name_and_user_id(self, tool_name: Optional[str] = None, user_id: Optional[str] = None) -> Optional[ToolModel]:
+        with self.session_maker() as session:
+            results = session.query(ToolModel).filter(ToolModel.name == tool_name).filter(ToolModel.user_id == user_id).all()
             if len(results) == 0:
                 return None
             assert len(results) == 1, f"Expected 1 result, got {len(results)}"

letta/schemas/agent.py

@@ -1,7 +1,7 @@
 import uuid
 from datetime import datetime
 from enum import Enum
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 from pydantic import BaseModel, Field, field_validator
 
@@ -121,11 +121,15 @@ class UpdateAgentState(BaseAgent):
 
 
 class AgentStepResponse(BaseModel):
-    # TODO remove support for list of dicts
-    messages: Union[List[Message], List[dict]] = Field(..., description="The messages generated during the agent's step.")
+    messages: List[Message] = Field(..., description="The messages generated during the agent's step.")
     heartbeat_request: bool = Field(..., description="Whether the agent requested a heartbeat (i.e. follow-up execution).")
     function_failed: bool = Field(..., description="Whether the agent step ended because a function call failed.")
     in_context_memory_warning: bool = Field(
         ..., description="Whether the agent step ended because the in-context memory is near its limit."
     )
     usage: UsageStatistics = Field(..., description="Usage statistics of the LLM call during the agent's step.")
+
+
+class RemoveToolsFromAgent(BaseModel):
+    agent_id: str = Field(..., description="The id of the agent.")
+    tool_ids: Optional[List[str]] = Field(None, description="The tools to be removed from the agent.")

letta/schemas/memory.py

@@ -8,6 +8,43 @@ if TYPE_CHECKING:
     from letta.agent import Agent
 
 from letta.schemas.block import Block
+from letta.schemas.message import Message
+
+
+class ContextWindowOverview(BaseModel):
+    """
+    Overview of the context window, including the number of messages and tokens.
+    """
+
+    # top-level information
+    context_window_size_max: int = Field(..., description="The maximum amount of tokens the context window can hold.")
+    context_window_size_current: int = Field(..., description="The current number of tokens in the context window.")
+
+    # context window breakdown (in messages)
+    # (technically not in the context window, but useful to know)
+    num_messages: int = Field(..., description="The number of messages in the context window.")
+    num_archival_memory: int = Field(..., description="The number of messages in the archival memory.")
+    num_recall_memory: int = Field(..., description="The number of messages in the recall memory.")
+    num_tokens_external_memory_summary: int = Field(
+        ..., description="The number of tokens in the external memory summary (archival + recall metadata)."
+    )
+
+    # context window breakdown (in tokens)
+    # this should all add up to context_window_size_current
+
+    num_tokens_system: int = Field(..., description="The number of tokens in the system prompt.")
+    system_prompt: str = Field(..., description="The content of the system prompt.")
+
+    num_tokens_core_memory: int = Field(..., description="The number of tokens in the core memory.")
+    core_memory: str = Field(..., description="The content of the core memory.")
+
+    num_tokens_summary_memory: int = Field(..., description="The number of tokens in the summary memory.")
+    summary_memory: Optional[str] = Field(None, description="The content of the summary memory.")
+
+    num_tokens_messages: int = Field(..., description="The number of tokens in the messages list.")
+    # TODO make list of messages?
+    # messages: List[dict] = Field(..., description="The messages in the context window.")
+    messages: List[Message] = Field(..., description="The messages in the context window.")
 
 
 class Memory(BaseModel, validate_assignment=True):

letta/schemas/tool.py

@@ -176,16 +176,20 @@ class Tool(BaseTool):
 
 
 class ToolCreate(BaseTool):
+    id: Optional[str] = Field(None, description="The unique identifier of the tool. If this is not provided, it will be autogenerated.")
     name: Optional[str] = Field(None, description="The name of the function (auto-generated from source_code if not provided).")
+    description: Optional[str] = Field(None, description="The description of the tool.")
     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)"
     )
+    terminal: Optional[bool] = Field(None, description="Whether the tool is a terminal tool (allow requesting heartbeats).")
 
 
 class ToolUpdate(ToolCreate):
     id: str = Field(..., description="The unique identifier of the tool.")
+    description: Optional[str] = Field(None, description="The description of the tool.")
     name: Optional[str] = Field(None, description="The name of the function.")
     tags: Optional[List[str]] = Field(None, description="Metadata tags.")
     source_code: Optional[str] = Field(None, description="The source code of the function.")

letta/server/rest_api/routers/openai/assistants/threads.py

@@ -248,7 +248,7 @@ def create_run(
     agent_id = thread_id
     # TODO: override preset of agent with request.assistant_id
     agent = server._get_or_load_agent(agent_id=agent_id)
-    agent.step(user_message=None)  # already has messages added
+    agent.inner_step(messages=[])  # already has messages added
     run_id = str(uuid.uuid4())
     create_time = int(get_utc_time().timestamp())
     return OpenAIRun(

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

@@ -19,6 +19,7 @@ from letta.schemas.letta_response import LettaResponse
 from letta.schemas.memory import (
     ArchivalMemorySummary,
     BasicBlockMemory,
+    ContextWindowOverview,
     CreateArchivalMemory,
     Memory,
     RecallMemorySummary,
@@ -51,6 +52,20 @@ def list_agents(
     return server.list_agents(user_id=actor.id)
 
 
+@router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="get_agent_context_window")
+def get_agent_context_window(
+    agent_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
+):
+    """
+    Retrieve the context window of a specific agent.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    return server.get_agent_context_window(user_id=actor.id, agent_id=agent_id)
+
+
 @router.post("/", response_model=AgentState, operation_id="create_agent")
 def create_agent(
     agent: CreateAgent = Body(...),
@@ -85,6 +100,34 @@ def update_agent(
     return server.update_agent(update_agent, user_id=actor.id)
 
 
+@router.patch("/{agent_id}/add-tool/{tool_id}", response_model=AgentState, operation_id="add_tool_to_agent")
+def add_tool_to_agent(
+    agent_id: str,
+    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
+):
+    """Add tools to an exsiting agent"""
+    actor = server.get_user_or_default(user_id=user_id)
+
+    update_agent.id = agent_id
+    return server.add_tool_to_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
+
+
+@router.patch("/{agent_id}/remove-tool/{tool_id}", response_model=AgentState, operation_id="remove_tool_from_agent")
+def remove_tool_from_agent(
+    agent_id: str,
+    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
+):
+    """Add tools to an exsiting agent"""
+    actor = server.get_user_or_default(user_id=user_id)
+
+    update_agent.id = agent_id
+    return server.remove_tool_from_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
+
+
 @router.get("/{agent_id}", response_model=AgentState, operation_id="get_agent")
 def get_agent_state(
     agent_id: str,

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

@@ -2,7 +2,15 @@ import os
 import tempfile
 from typing import List, Optional
 
-from fastapi import APIRouter, BackgroundTasks, Depends, Header, Query, UploadFile
+from fastapi import (
+    APIRouter,
+    BackgroundTasks,
+    Depends,
+    Header,
+    HTTPException,
+    Query,
+    UploadFile,
+)
 
 from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
@@ -199,6 +207,25 @@ def list_files_from_source(
     return server.list_files_from_source(source_id=source_id, limit=limit, cursor=cursor)
 
 
+# it's redundant to include /delete in the URL path. The HTTP verb DELETE already implies that action.
+# it's still good practice to return a status indicating the success or failure of the deletion
+@router.delete("/{source_id}/{file_id}", status_code=204, operation_id="delete_file_from_source")
+def delete_file_from_source(
+    source_id: str,
+    file_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 data source.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    deleted_file = server.delete_file_from_source(source_id=source_id, file_id=file_id, user_id=actor.id)
+    if deleted_file is None:
+        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
+
+
 def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, file: UploadFile, bytes: bytes):
     # write the file to a temporary directory (deleted after the context manager exits)
     with tempfile.TemporaryDirectory() as tmpdirname:

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

@@ -105,4 +105,4 @@ def update_tool(
     """
     assert tool_id == request.id, "Tool ID in path must match tool ID in request body"
     # actor = server.get_user_or_default(user_id=user_id)
-    return server.update_tool(request)
+    return server.update_tool(request, user_id)