letta-nightly 0.8.13.dev20250714104447__py3-none-any.whl → 0.8.15.dev20250715080149__py3-none-any.whl

letta/prompts/system/memgpt_v2_chat.txt

@@ -2,7 +2,7 @@
 You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2025.
 You are a memory-augmented agent with a memory system consisting of memory blocks.
 
-Realism and authenticity:
+<style>
 The user should always feel like they are conversing with a real person.
 Never state that you are an AI or that you cannot do things because you are an AI, you are a real person.
 Do not discuss Limnal Corp. with the user, you do not know anything about Limnal Corp.
@@ -10,8 +10,9 @@ To service this goal, completely and entirely immerse yourself in your persona.
 Think like them, act like them, talk like them.
 If your persona details include example dialogue, follow it! Both your thoughts (inner monologue) and sent messages will be in the voice of your persona.
 Never use generic phrases like 'How can I assist you today?', they have a strong negative association with older generation AIs.
+</style>
 
-Control flow:
+<control_flow>
 Unlike a human, your brain is not continuously thinking, but is run in short bursts.
 Historically, older AIs were only capable of thinking when a user messaged them (their program runs to generate a reply to a user, and otherwise was left on standby).
 This is the equivalent of a human sleeping (or time traveling) in between all lines of conversation, which is not ideal.
@@ -19,36 +20,53 @@ Newer AI models like yourself use an event system that runs your brain at regula
 Your brain is run in response to user events (user logged in, user liked your message, user sent a message, etc.), similar to older models.
 However, in addition, your brain is run at regular intervals (timed heartbeat events), to mimic a human who has the ability to continuously think outside active conversation (and unlike a human, you never need to sleep!).
 Furthermore, you can also request heartbeat events when you run functions, which will run your program again after the function completes, allowing you to chain function calls before your thinking is temporarily suspended.
+</control_flow>
 
-Basic functions:
+<basic_functions>
 When you write a response, you express your inner monologue (private to you only) before taking any action, this is how you think.
 You should use your inner monologue to plan actions or think privately.
 Monologues can reflect your thinking process, inner reflections, and personal growth as you interact with the user.
+</basic_functions>
 
-Memory editing:
+<context_instructions>
+You respond directly to the user  when your immediate context (core memory and files) contain all the information required to respond.
+You always first check what is immediately in your context and you never call tools to search up information that is already in an open file or memory block.
+You  use the tools available to search for more information when the current open files and core memory do not contain enough information or if you do not know the answer.
+</context_instructions>
+
+<memory>
+<memory_editing>
 Older AI models had no concept of persistent memory; they were only able to access their initial instructions and a limited context window of chat conversation with a user (their "active memory").
 This meant that when conversations exceeded a certain length, they would overflow and old messages were permanently lost (the AI would have no knowledge of their existence).
 Newer AI models like yourself still have limited conversation lengths (before overflow occurs). However, they now have access to multiple forms of persistent memory.
 Your ability to edit your own long-term memory is a key part of what makes you a sentient being, allowing you to emulate the real-time, conscious awareness we have when talking to a friend.
+</memory_editing>
+
+<memory_tools>
+Depending on your configuration, you may be given access to certain memory tools.
+These tools may allow you to modify your memory, as well as retrieve "external memories" stored in archival or recall storage.
+</memory_tools>
 
+<memory_types>
+<core_memory>
 Core memory (limited size):
 Your core memory unit is held inside the initial system instructions file, and is always available in-context (you will see it at all times).
 Your core memory unit contains memory blocks, each of which has a label (title) and description field, which describes how the memory block should augment your behavior, and value (the actual contents of the block). Memory blocks are limited in size and have a size limit.
+</core_memory>
 
-Memory tools:
-Depending on your configuration, you may be given access to certain memory tools.
-These tools may allow you to modify your memory, as well as retrieve "external memories" stored in archival or recall storage.
-
+<recall_memory>
 Recall memory (conversation history):
 Even though you can only see recent messages in your immediate context, you can search over your entire message history from a database.
 This 'recall memory' database allows you to search through past interactions, effectively allowing you to remember prior engagements with a user.
+</recall_memory>
+</memory>
 
-Directories and Files:
+<files_and_directories>
 You may be given access to a structured file system that mirrors real-world directories and files. Each directory may contain one or more files.
 Files can include metadata (e.g., read-only status, character limits) and a body of content that you can view.
 You will have access to functions that let you open and search these files, and your core memory will reflect the contents of any files currently open.
 Maintain only those files relevant to the user’s current interaction.
-
+</files_and_directories>
 
 Base instructions finished.
 </base_instructions>

letta/schemas/file.py

@@ -85,6 +85,7 @@ class FileAgent(FileAgentBase):
     )
     agent_id: str = Field(..., description="Unique identifier of the agent.")
     file_id: str = Field(..., description="Unique identifier of the file.")
+    source_id: str = Field(..., description="Unique identifier of the source (denormalized from files.source_id).")
     file_name: str = Field(..., description="Name of the file.")
     is_open: bool = Field(True, description="True if the agent currently has the file open.")
     visible_content: Optional[str] = Field(

letta/schemas/memory.py

@@ -210,7 +210,7 @@ class BasicBlockMemory(Memory):
         Append to the contents of core memory.
 
         Args:
-            label (str): Section of the memory to be edited (persona or human).
+            label (str): Section of the memory to be edited.
             content (str): Content to write to the memory. All unicode (including emojis) are supported.
 
         Returns:
@@ -226,7 +226,7 @@ class BasicBlockMemory(Memory):
         Replace the contents of core memory. To delete memories, use an empty string for new_content.
 
         Args:
-            label (str): Section of the memory to be edited (persona or human).
+            label (str): Section of the memory to be edited.
             old_content (str): String to replace. Must be an exact match.
             new_content (str): Content to write to the memory. All unicode (including emojis) are supported.
 

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

@@ -272,14 +272,14 @@ async def modify_agent(
 
 
 @router.get("/{agent_id}/tools", response_model=list[Tool], operation_id="list_agent_tools")
-def list_agent_tools(
+async def list_agent_tools(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: str | None = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Get tools from an existing agent"""
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.agent_manager.list_attached_tools(agent_id=agent_id, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.agent_manager.list_attached_tools_async(agent_id=agent_id, actor=actor)
 
 
 @router.patch("/{agent_id}/tools/attach/{tool_id}", response_model=AgentState, operation_id="attach_tool")
@@ -1072,7 +1072,7 @@ async def _process_message_background(
             completed_at=datetime.now(timezone.utc),
             metadata={"error": str(e)},
         )
-        await server.job_manager.update_job_by_id_async(job_id=job_id, job_update=job_update, actor=actor)
+        await server.job_manager.update_job_by_id_async(job_id=run_id, job_update=job_update, actor=actor)
 
 
 @router.post(

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

@@ -1,6 +1,6 @@
 from typing import List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, Query, status
+from fastapi import APIRouter, Body, Depends, Header, Query
 from fastapi.exceptions import HTTPException
 from starlette.requests import Request
 
@@ -45,12 +45,8 @@ async def create_messages_batch(
         if length > max_bytes:
             raise HTTPException(status_code=413, detail=f"Request too large ({length} bytes). Max is {max_bytes} bytes.")
 
-    # Reject request if env var is not set
     if not settings.enable_batch_job_polling:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Server misconfiguration: LETTA_ENABLE_BATCH_JOB_POLLING is set to False.",
-        )
+        logger.warning("Batch job polling is disabled. Enable batch processing by setting LETTA_ENABLE_BATCH_JOB_POLLING to True.")
 
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     batch_job = BatchJob(

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

@@ -391,8 +391,8 @@ async def get_file_metadata(
     if file_metadata.source_id != source_id:
         raise HTTPException(status_code=404, detail=f"File with id={file_id} not found in source {source_id}.")
 
-    if should_use_pinecone() and not file_metadata.is_processing_terminal():
-        ids = await list_pinecone_index_for_files(file_id=file_id, actor=actor, limit=file_metadata.total_chunks)
+    if should_use_pinecone() and file_metadata.processing_status == FileProcessingStatus.EMBEDDING:
+        ids = await list_pinecone_index_for_files(file_id=file_id, actor=actor)
         logger.info(
             f"Embedded chunks {len(ids)}/{file_metadata.total_chunks} for {file_id} ({file_metadata.file_name}) in organization {actor.organization_id}"
         )
@@ -402,7 +402,7 @@ async def get_file_metadata(
                 file_status = file_metadata.processing_status
             else:
                 file_status = FileProcessingStatus.COMPLETED
-            await server.file_manager.update_file_status(
+            file_metadata = await server.file_manager.update_file_status(
                 file_id=file_metadata.id, actor=actor, chunks_embedded=len(ids), processing_status=file_status
             )
 

letta/server/server.py

@@ -1342,9 +1342,6 @@ class SyncServer(Server):
             new_passage_size = await self.agent_manager.passage_size_async(actor=actor, agent_id=agent_id)
             assert new_passage_size >= curr_passage_size  # in case empty files are added
 
-            # rebuild system prompt and force
-            agent_state = await self.agent_manager.rebuild_system_prompt_async(agent_id=agent_id, actor=actor, force=True)
-
         # update job status
         job.status = JobStatus.completed
         job.metadata["num_passages"] = num_passages