letta-nightly 0.4.1.dev20241013104006__py3-none-any.whl → 0.5.0.dev20241015014828__py3-none-any.whl

letta/schemas/file.py

@@ -0,0 +1,31 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+from letta.utils import get_utc_time
+
+
+class FileMetadataBase(LettaBase):
+    """Base class for FileMetadata schemas"""
+
+    __id_prefix__ = "file"
+
+
+class FileMetadata(FileMetadataBase):
+    """Representation of a single FileMetadata"""
+
+    id: str = FileMetadataBase.generate_id_field()
+    user_id: str = Field(description="The unique identifier of the user associated with the document.")
+    source_id: str = Field(..., description="The unique identifier of the source associated with the document.")
+    file_name: Optional[str] = Field(None, description="The name of the file.")
+    file_path: Optional[str] = Field(None, description="The path to the file.")
+    file_type: Optional[str] = Field(None, description="The type of the file (MIME type).")
+    file_size: Optional[int] = Field(None, description="The size of the file in bytes.")
+    file_creation_date: Optional[str] = Field(None, description="The creation date of the file.")
+    file_last_modified_date: Optional[str] = Field(None, description="The last modified date of the file.")
+    created_at: datetime = Field(default_factory=get_utc_time, description="The creation date of this file metadata object.")
+
+    class Config:
+        extra = "allow"

letta/schemas/job.py

@@ -15,7 +15,7 @@ class JobBase(LettaBase):
 
 class Job(JobBase):
     """
-    Representation of offline jobs, used for tracking status of data loading tasks (involving parsing and embedding documents).
+    Representation of offline jobs, used for tracking status of data loading tasks (involving parsing and embedding files).
 
     Parameters:
         id (str): The unique identifier of the job.

letta/schemas/letta_request.py

@@ -1,13 +1,13 @@
-from typing import List
+from typing import List, Union
 
 from pydantic import BaseModel, Field
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
-from letta.schemas.message import MessageCreate
+from letta.schemas.message import Message, MessageCreate
 
 
 class LettaRequest(BaseModel):
-    messages: List[MessageCreate] = Field(..., description="The messages to be sent to the agent.")
+    messages: Union[List[MessageCreate], List[Message]] = Field(..., description="The messages to be sent to the agent.")
     run_async: bool = Field(default=False, description="Whether to asynchronously send the messages to the agent.")  # TODO: implement
 
     stream_steps: bool = Field(

letta/schemas/llm_config.py

@@ -33,6 +33,7 @@ class LLMConfig(BaseModel):
         "koboldcpp",
         "vllm",
         "hugging-face",
+        "mistral",
     ] = Field(..., description="The endpoint type for the model.")
     model_endpoint: Optional[str] = Field(None, description="The endpoint for the model.")
     model_wrapper: Optional[str] = Field(None, description="The wrapper for the model.")

letta/schemas/message.py

@@ -2,7 +2,7 @@ import copy
 import json
 import warnings
 from datetime import datetime, timezone
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from pydantic import Field, field_validator
 
@@ -57,7 +57,11 @@ class BaseMessage(LettaBase):
 class MessageCreate(BaseMessage):
     """Request to create a message"""
 
-    role: MessageRole = Field(..., description="The role of the participant.")
+    # In the simplified format, only allow simple roles
+    role: Literal[
+        MessageRole.user,
+        MessageRole.system,
+    ] = Field(..., description="The role of the participant.")
     text: str = Field(..., description="The text of the message.")
     name: Optional[str] = Field(None, description="The name of the participant.")
 

letta/schemas/passage.py

@@ -19,8 +19,8 @@ class PassageBase(LettaBase):
     # origin data source
     source_id: Optional[str] = Field(None, description="The data source of the passage.")
 
-    # document association
-    doc_id: Optional[str] = Field(None, description="The unique identifier of the document associated with the passage.")
+    # file association
+    file_id: Optional[str] = Field(None, description="The unique identifier of the file associated with the passage.")
     metadata_: Optional[Dict] = Field({}, description="The metadata of the passage.")
 
 
@@ -36,7 +36,7 @@ class Passage(PassageBase):
         user_id (str): The unique identifier of the user associated with the passage.
         agent_id (str): The unique identifier of the agent associated with the passage.
         source_id (str): The data source of the passage.
-        doc_id (str): The unique identifier of the document associated with the passage.
+        file_id (str): The unique identifier of the file associated with the passage.
     """
 
     id: str = PassageBase.generate_id_field()

letta/schemas/source.py

@@ -28,7 +28,7 @@ class SourceCreate(BaseSource):
 
 class Source(BaseSource):
     """
-    Representation of a source, which is a collection of documents and passages.
+    Representation of a source, which is a collection of files and passages.
 
     Parameters:
         id (str): The ID of the source
@@ -59,4 +59,4 @@ class UploadFileToSourceRequest(BaseModel):
 class UploadFileToSourceResponse(BaseModel):
     source: Source = Field(..., description="The source the file was uploaded to.")
     added_passages: int = Field(..., description="The number of passages added to the source.")
-    added_documents: int = Field(..., description="The number of documents added to the source.")
+    added_documents: int = Field(..., description="The number of files added to the source.")

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

@@ -8,7 +8,7 @@ from starlette.responses import StreamingResponse
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgentState
-from letta.schemas.enums import MessageRole, MessageStreamStatus
+from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import (
     LegacyLettaMessage,
     LettaMessage,
@@ -23,7 +23,7 @@ from letta.schemas.memory import (
     Memory,
     RecallMemorySummary,
 )
-from letta.schemas.message import Message, UpdateMessage
+from letta.schemas.message import Message, MessageCreate, UpdateMessage
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
 from letta.server.rest_api.interface import StreamingServerInterface
@@ -326,14 +326,15 @@ async def send_message(
 
     # TODO(charles): support sending multiple messages
     assert len(request.messages) == 1, f"Multiple messages not supported: {request.messages}"
-    message = request.messages[0]
+    request.messages[0]
 
     return await send_message_to_agent(
         server=server,
         agent_id=agent_id,
         user_id=actor.id,
-        role=message.role,
-        message=message.text,
+        # role=message.role,
+        # message=message.text,
+        messages=request.messages,
         stream_steps=request.stream_steps,
         stream_tokens=request.stream_tokens,
         return_message_object=request.return_message_object,
@@ -349,8 +350,8 @@ async def send_message_to_agent(
     server: SyncServer,
     agent_id: str,
     user_id: str,
-    role: MessageRole,
-    message: str,
+    # role: MessageRole,
+    messages: Union[List[Message], List[MessageCreate]],
     stream_steps: bool,
     stream_tokens: bool,
     # related to whether or not we return `LettaMessage`s or `Message`s
@@ -367,14 +368,6 @@ async def send_message_to_agent(
     # TODO: @charles is this the correct way to handle?
     include_final_message = True
 
-    # determine role
-    if role == MessageRole.user:
-        message_func = server.user_message
-    elif role == MessageRole.system:
-        message_func = server.system_message
-    else:
-        raise HTTPException(status_code=500, detail=f"Bad role {role}")
-
     if not stream_steps and stream_tokens:
         raise HTTPException(status_code=400, detail="stream_steps must be 'true' if stream_tokens is 'true'")
 
@@ -413,7 +406,8 @@ async def send_message_to_agent(
         # Offload the synchronous message_func to a separate thread
         streaming_interface.stream_start()
         task = asyncio.create_task(
-            asyncio.to_thread(message_func, user_id=user_id, agent_id=agent_id, message=message, timestamp=timestamp)
+            # asyncio.to_thread(message_func, user_id=user_id, agent_id=agent_id, message=message, timestamp=timestamp)
+            asyncio.to_thread(server.send_messages, user_id=user_id, agent_id=agent_id, messages=messages)
         )
 
         if stream_steps:

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

@@ -1,6 +1,6 @@
 from typing import List, Optional
 
-from fastapi import APIRouter, Depends, Header, Query
+from fastapi import APIRouter, Depends, Header, HTTPException, Query
 
 from letta.schemas.job import Job
 from letta.server.rest_api.utils import get_letta_server
@@ -54,3 +54,19 @@ def get_job(
     """
 
     return server.get_job(job_id=job_id)
+
+
+@router.delete("/{job_id}", response_model=Job, operation_id="delete_job")
+def delete_job(
+    job_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Delete a job by its job_id.
+    """
+    job = server.get_job(job_id=job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+
+    server.delete_job(job_id=job_id)
+    return job

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

@@ -4,7 +4,7 @@ from typing import List, Optional
 
 from fastapi import APIRouter, BackgroundTasks, Depends, Header, Query, UploadFile
 
-from letta.schemas.document import Document
+from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
@@ -186,19 +186,17 @@ def list_passages(
     return passages
 
 
-@router.get("/{source_id}/documents", response_model=List[Document], operation_id="list_source_documents")
-def list_documents(
+@router.get("/{source_id}/files", response_model=List[FileMetadata], operation_id="list_files_from_source")
+def list_files_from_source(
     source_id: str,
+    limit: int = Query(1000, description="Number of files to return"),
+    cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
     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
 ):
     """
-    List all documents associated with a data source.
+    List paginated files associated with a data source.
     """
-    actor = server.get_user_or_default(user_id=user_id)
-
-    documents = server.list_data_source_documents(user_id=actor.id, source_id=source_id)
-    return documents
+    return server.list_files_from_source(source_id=source_id, limit=limit, cursor=cursor)
 
 
 def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, file: UploadFile, bytes: bytes):

letta/server/server.py

@@ -47,6 +47,7 @@ from letta.providers import (
     AnthropicProvider,
     AzureProvider,
     GoogleAIProvider,
+    GroqProvider,
     LettaProvider,
     OllamaProvider,
     OpenAIProvider,
@@ -63,16 +64,16 @@ from letta.schemas.block import (
     CreatePersona,
     UpdateBlock,
 )
-from letta.schemas.document import Document
 from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
 from letta.schemas.enums import JobStatus
+from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.letta_message import LettaMessage
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, Memory, RecallMemorySummary
-from letta.schemas.message import Message, UpdateMessage
+from letta.schemas.message import Message, MessageCreate, MessageRole, UpdateMessage
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.organization import Organization, OrganizationCreate
 from letta.schemas.passage import Passage
@@ -141,6 +142,11 @@ class Server(object):
         """Process a message from the system, internally calls step"""
         raise NotImplementedError
 
+    @abstractmethod
+    def send_messages(self, user_id: str, agent_id: str, messages: Union[MessageCreate, List[Message]]) -> None:
+        """Send a list of messages to the agent"""
+        raise NotImplementedError
+
     @abstractmethod
     def run_command(self, user_id: str, agent_id: str, command: str) -> Union[str, None]:
         """Run a command on the agent, e.g. /memory
@@ -292,6 +298,12 @@ class SyncServer(Server):
                     base_url=model_settings.vllm_api_base,
                 )
             )
+        if model_settings.groq_api_key:
+            self._enabled_providers.append(
+                GroqProvider(
+                    api_key=model_settings.groq_api_key,
+                )
+            )
 
     def save_agents(self):
         """Saves all the agents that are in the in-memory object store"""
@@ -383,9 +395,22 @@ class SyncServer(Server):
             letta_agent = self._load_agent(user_id=user_id, agent_id=agent_id)
         return letta_agent
 
-    def _step(self, user_id: str, agent_id: str, input_message: Union[str, Message], timestamp: Optional[datetime]) -> LettaUsageStatistics:
+    def _step(
+        self,
+        user_id: str,
+        agent_id: str,
+        input_messages: Union[Message, List[Message]],
+        # timestamp: Optional[datetime],
+    ) -> LettaUsageStatistics:
         """Send the input message through the agent"""
-        logger.debug(f"Got input message: {input_message}")
+
+        # Input validation
+        if isinstance(input_messages, Message):
+            input_messages = [input_messages]
+        if not all(isinstance(m, Message) for m in input_messages):
+            raise ValueError(f"messages should be a Message or a list of Message, got {type(input_messages)}")
+
+        logger.debug(f"Got input messages: {input_messages}")
         try:
 
             # Get the agent object (loaded in memory)
@@ -398,18 +423,18 @@ class SyncServer(Server):
 
             logger.debug(f"Starting agent step")
             no_verify = True
-            next_input_message = input_message
+            next_input_message = input_messages
             counter = 0
             total_usage = UsageStatistics()
             step_count = 0
             while True:
                 step_response = letta_agent.step(
-                    next_input_message,
+                    messages=next_input_message,
                     first_message=False,
                     skip_verify=no_verify,
                     return_dicts=False,
                     stream=token_streaming,
-                    timestamp=timestamp,
+                    # timestamp=timestamp,
                     ms=self.ms,
                 )
                 step_response.messages
@@ -436,13 +461,40 @@ class SyncServer(Server):
                     break
                 # Chain handlers
                 elif token_warning:
-                    next_input_message = system.get_token_limit_warning()
+                    assert letta_agent.agent_state.user_id is not None
+                    next_input_message = Message.dict_to_message(
+                        agent_id=letta_agent.agent_state.id,
+                        user_id=letta_agent.agent_state.user_id,
+                        model=letta_agent.model,
+                        openai_message_dict={
+                            "role": "user",  # TODO: change to system?
+                            "content": system.get_token_limit_warning(),
+                        },
+                    )
                     continue  # always chain
                 elif function_failed:
-                    next_input_message = system.get_heartbeat(constants.FUNC_FAILED_HEARTBEAT_MESSAGE)
+                    assert letta_agent.agent_state.user_id is not None
+                    next_input_message = Message.dict_to_message(
+                        agent_id=letta_agent.agent_state.id,
+                        user_id=letta_agent.agent_state.user_id,
+                        model=letta_agent.model,
+                        openai_message_dict={
+                            "role": "user",  # TODO: change to system?
+                            "content": system.get_heartbeat(constants.FUNC_FAILED_HEARTBEAT_MESSAGE),
+                        },
+                    )
                     continue  # always chain
                 elif heartbeat_request:
-                    next_input_message = system.get_heartbeat(constants.REQ_HEARTBEAT_MESSAGE)
+                    assert letta_agent.agent_state.user_id is not None
+                    next_input_message = Message.dict_to_message(
+                        agent_id=letta_agent.agent_state.id,
+                        user_id=letta_agent.agent_state.user_id,
+                        model=letta_agent.model,
+                        openai_message_dict={
+                            "role": "user",  # TODO: change to system?
+                            "content": system.get_heartbeat(constants.REQ_HEARTBEAT_MESSAGE),
+                        },
+                    )
                     continue  # always chain
                 # Letta no-op / yield
                 else:
@@ -621,7 +673,7 @@ class SyncServer(Server):
                 )
 
         # Run the agent state forward
-        usage = self._step(user_id=user_id, agent_id=agent_id, input_message=message, timestamp=timestamp)
+        usage = self._step(user_id=user_id, agent_id=agent_id, input_messages=message)
         return usage
 
     def system_message(
@@ -669,7 +721,7 @@ class SyncServer(Server):
 
         if isinstance(message, Message):
             # Can't have a null text field
-            if len(message.text) == 0 or message.text is None:
+            if message.text is None or len(message.text) == 0:
                 raise ValueError(f"Invalid input: '{message.text}'")
             # If the input begins with a command prefix, reject
             elif message.text.startswith("/"):
@@ -683,7 +735,69 @@ class SyncServer(Server):
             message.created_at = timestamp
 
         # Run the agent state forward
-        return self._step(user_id=user_id, agent_id=agent_id, input_message=packaged_system_message, timestamp=timestamp)
+        return self._step(user_id=user_id, agent_id=agent_id, input_messages=message)
+
+    def send_messages(
+        self,
+        user_id: str,
+        agent_id: str,
+        messages: Union[List[MessageCreate], List[Message]],
+        # whether or not to wrap user and system message as MemGPT-style stringified JSON
+        wrap_user_message: bool = True,
+        wrap_system_message: bool = True,
+    ) -> LettaUsageStatistics:
+        """Send a list of messages to the agent
+
+        If the messages are of type MessageCreate, we need to turn them into
+        Message objects first before sending them through step.
+
+        Otherwise, we can pass them in directly.
+        """
+        if self.ms.get_user(user_id=user_id) is None:
+            raise ValueError(f"User user_id={user_id} does not exist")
+        if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
+            raise ValueError(f"Agent agent_id={agent_id} does not exist")
+
+        message_objects: List[Message] = []
+
+        if all(isinstance(m, MessageCreate) for m in messages):
+            for message in messages:
+                assert isinstance(message, MessageCreate)
+
+                # If wrapping is eanbled, wrap with metadata before placing content inside the Message object
+                if message.role == MessageRole.user and wrap_user_message:
+                    message.text = system.package_user_message(user_message=message.text)
+                elif message.role == MessageRole.system and wrap_system_message:
+                    message.text = system.package_system_message(system_message=message.text)
+                else:
+                    raise ValueError(f"Invalid message role: {message.role}")
+
+                # Create the Message object
+                message_objects.append(
+                    Message(
+                        user_id=user_id,
+                        agent_id=agent_id,
+                        role=message.role,
+                        text=message.text,
+                        name=message.name,
+                        # assigned later?
+                        model=None,
+                        # irrelevant
+                        tool_calls=None,
+                        tool_call_id=None,
+                    )
+                )
+
+        elif all(isinstance(m, Message) for m in messages):
+            for message in messages:
+                assert isinstance(message, Message)
+                message_objects.append(message)
+
+        else:
+            raise ValueError(f"All messages must be of type Message or MessageCreate, got {type(messages)}")
+
+        # Run the agent state forward
+        return self._step(user_id=user_id, agent_id=agent_id, input_messages=message_objects)
 
     # @LockingServer.agent_lock_decorator
     def run_command(self, user_id: str, agent_id: str, command: str) -> LettaUsageStatistics:
@@ -1556,7 +1670,7 @@ class SyncServer(Server):
         #    job.status = JobStatus.failed
         #    job.metadata_["error"] = error
         #    self.ms.update_job(job)
-        #    # TODO: delete any associated passages/documents?
+        #    # TODO: delete any associated passages/files?
 
         #    # return failed job
         #    return job
@@ -1585,11 +1699,10 @@ class SyncServer(Server):
 
         # get the data connectors
         passage_store = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
-        # TODO: add document store support
-        document_store = None  # StorageConnector.get_storage_connector(TableType.DOCUMENTS, self.config, user_id=user_id)
+        file_store = StorageConnector.get_storage_connector(TableType.FILES, self.config, user_id=user_id)
 
         # load data into the document store
-        passage_count, document_count = load_data(connector, source, passage_store, document_store)
+        passage_count, document_count = load_data(connector, source, passage_store, file_store)
         return passage_count, document_count
 
     def attach_source_to_agent(
@@ -1646,14 +1759,14 @@ class SyncServer(Server):
         # list all attached sources to an agent
         return self.ms.list_attached_sources(agent_id)
 
+    def list_files_from_source(self, source_id: str, limit: int = 1000, cursor: Optional[str] = None) -> List[FileMetadata]:
+        # list all attached sources to an agent
+        return self.ms.list_files_from_source(source_id=source_id, limit=limit, cursor=cursor)
+
     def list_data_source_passages(self, user_id: str, source_id: str) -> List[Passage]:
         warnings.warn("list_data_source_passages is not yet implemented, returning empty list.", category=UserWarning)
         return []
 
-    def list_data_source_documents(self, user_id: str, source_id: str) -> List[Document]:
-        warnings.warn("list_data_source_documents is not yet implemented, returning empty list.", category=UserWarning)
-        return []
-
     def list_all_sources(self, user_id: str) -> List[Source]:
         """List all sources (w/ extra metadata) belonging to a user"""
 
@@ -1667,9 +1780,9 @@ class SyncServer(Server):
             passage_conn = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
             num_passages = passage_conn.size({"source_id": source.id})
 
-            # TODO: add when documents table implemented
-            ## count number of documents
-            # document_conn = StorageConnector.get_storage_connector(TableType.DOCUMENTS, self.config, user_id=user_id)
+            # TODO: add when files table implemented
+            ## count number of files
+            # document_conn = StorageConnector.get_storage_connector(TableType.FILES, self.config, user_id=user_id)
             # num_documents = document_conn.size({"data_source": source.name})
             num_documents = 0