letta-nightly 0.7.5.dev20250426104040__tar.gz → 0.7.5.dev20250428110034__tar.gz

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.5.dev20250426104040
+Version: 0.7.5.dev20250428110034
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/agents/letta_agent.py

@@ -57,6 +57,7 @@ class LettaAgent(BaseAgent):
         self.block_manager = block_manager
         self.passage_manager = passage_manager
         self.use_assistant_message = use_assistant_message
+        self.response_messages: List[Message] = []
 
     @trace_method
     async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
@@ -81,6 +82,7 @@ class LettaAgent(BaseAgent):
 
             tool_call = response.choices[0].message.tool_calls[0]
             persisted_messages, should_continue = await self._handle_ai_response(tool_call, agent_state, tool_rules_solver)
+            self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
 
             if not should_continue:
@@ -139,6 +141,7 @@ class LettaAgent(BaseAgent):
                 pre_computed_assistant_message_id=interface.letta_assistant_message_id,
                 pre_computed_tool_message_id=interface.letta_tool_message_id,
             )
+            self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
 
             if not should_continue:
@@ -167,7 +170,14 @@ class LettaAgent(BaseAgent):
         tools = [
             t
             for t in agent_state.tools
-            if t.tool_type in {ToolType.CUSTOM, ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE}
+            if t.tool_type
+            in {
+                ToolType.CUSTOM,
+                ToolType.LETTA_CORE,
+                ToolType.LETTA_MEMORY_CORE,
+                ToolType.LETTA_MULTI_AGENT_CORE,
+                ToolType.LETTA_SLEEPTIME_CORE,
+            }
             or (t.tool_type == ToolType.LETTA_MULTI_AGENT_CORE and t.name == "send_message_to_agents_matching_tags")
         ]
 

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/groups/helpers.py

@@ -88,11 +88,14 @@ def load_multi_agent(
 def stringify_message(message: Message, use_assistant_name: bool = False) -> str | None:
     assistant_name = message.name or "assistant" if use_assistant_name else "assistant"
     if message.role == "user":
-        content = json.loads(message.content[0].text)
-        if content["type"] == "user_message":
-            return f"{message.name or 'user'}: {content['message']}"
-        else:
-            return None
+        try:
+            content = json.loads(message.content[0].text)
+            if content["type"] == "user_message":
+                return f"{message.name or 'user'}: {content['message']}"
+            else:
+                return None
+        except:
+            return f"{message.name or 'user'}: {message.content[0].text}"
     elif message.role == "assistant":
         messages = []
         if message.tool_calls:

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/groups/sleeptime_multi_agent.py

@@ -107,6 +107,9 @@ class SleeptimeMultiAgent(Agent):
         run_id: str,
     ) -> LettaUsageStatistics:
         try:
+            job_update = JobUpdate(status=JobStatus.running)
+            self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.user)
+
             participant_agent_state = self.agent_manager.get_agent_by_id(participant_agent_id, actor=self.user)
             participant_agent = Agent(
                 agent_state=participant_agent_state,

letta_nightly-0.7.5.dev20250428110034/letta/groups/sleeptime_multi_agent_v2.py

@@ -0,0 +1,249 @@
+import asyncio
+from datetime import datetime, timezone
+from typing import AsyncGenerator, List, Optional
+
+from letta.agents.base_agent import BaseAgent
+from letta.agents.letta_agent import LettaAgent
+from letta.groups.helpers import stringify_message
+from letta.schemas.enums import JobStatus
+from letta.schemas.group import Group, ManagerType
+from letta.schemas.job import JobUpdate
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.letta_response import LettaResponse
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.run import Run
+from letta.schemas.user import User
+from letta.services.agent_manager import AgentManager
+from letta.services.block_manager import BlockManager
+from letta.services.group_manager import GroupManager
+from letta.services.job_manager import JobManager
+from letta.services.message_manager import MessageManager
+from letta.services.passage_manager import PassageManager
+
+
+class SleeptimeMultiAgentV2(BaseAgent):
+    def __init__(
+        self,
+        agent_id: str,
+        message_manager: MessageManager,
+        agent_manager: AgentManager,
+        block_manager: BlockManager,
+        passage_manager: PassageManager,
+        group_manager: GroupManager,
+        job_manager: JobManager,
+        actor: User,
+        group: Optional[Group] = None,
+    ):
+        super().__init__(
+            agent_id=agent_id,
+            openai_client=None,
+            message_manager=message_manager,
+            agent_manager=agent_manager,
+            actor=actor,
+        )
+        self.block_manager = block_manager
+        self.passage_manager = passage_manager
+        self.group_manager = group_manager
+        self.job_manager = job_manager
+        # Group settings
+        assert group.manager_type == ManagerType.sleeptime, f"Expected group manager type to be 'sleeptime', got {group.manager_type}"
+        self.group = group
+
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
+        run_ids = []
+
+        # Prepare new messages
+        new_messages = []
+        for message in input_messages:
+            if isinstance(message.content, str):
+                message.content = [TextContent(text=message.content)]
+            message.group_id = self.group.id
+            new_messages.append(message)
+
+        # Load foreground agent
+        foreground_agent = LettaAgent(
+            agent_id=self.agent_id,
+            message_manager=self.message_manager,
+            agent_manager=self.agent_manager,
+            block_manager=self.block_manager,
+            passage_manager=self.passage_manager,
+            actor=self.actor,
+        )
+        # Perform foreground agent step
+        response = await foreground_agent.step(input_messages=new_messages, max_steps=max_steps)
+
+        # Get last response messages
+        last_response_messages = foreground_agent.response_messages
+
+        # Update turns counter
+        if self.group.sleeptime_agent_frequency is not None and self.group.sleeptime_agent_frequency > 0:
+            turns_counter = self.group_manager.bump_turns_counter(group_id=self.group.id, actor=self.actor)
+
+        # Perform participant steps
+        if self.group.sleeptime_agent_frequency is None or (
+            turns_counter is not None and turns_counter % self.group.sleeptime_agent_frequency == 0
+        ):
+            last_processed_message_id = self.group_manager.get_last_processed_message_id_and_update(
+                group_id=self.group.id, last_processed_message_id=last_response_messages[-1].id, actor=self.actor
+            )
+            for participant_agent_id in self.group.agent_ids:
+                try:
+                    run_id = await self._issue_background_task(
+                        participant_agent_id,
+                        last_response_messages,
+                        last_processed_message_id,
+                    )
+                    run_ids.append(run_id)
+
+                except Exception as e:
+                    # Individual task failures
+                    print(f"Agent processing failed: {str(e)}")
+                    raise e
+
+        response.usage.run_ids = run_ids
+        return response
+
+    async def step_stream(self, input_messages: List[MessageCreate], max_steps: int = 10) -> AsyncGenerator[str, None]:
+        # Prepare new messages
+        new_messages = []
+        for message in input_messages:
+            if isinstance(message.content, str):
+                message.content = [TextContent(text=message.content)]
+            message.group_id = self.group.id
+            new_messages.append(message)
+
+        # Load foreground agent
+        foreground_agent = LettaAgent(
+            agent_id=self.agent_id,
+            message_manager=self.message_manager,
+            agent_manager=self.agent_manager,
+            block_manager=self.block_manager,
+            passage_manager=self.passage_manager,
+            actor=self.actor,
+        )
+        # Perform foreground agent step
+        async for chunk in foreground_agent.step_stream(input_messages=new_messages, max_steps=max_steps):
+            yield chunk
+
+        # Get response messages
+        last_response_messages = foreground_agent.response_messages
+
+        # Update turns counter
+        if self.group.sleeptime_agent_frequency is not None and self.group.sleeptime_agent_frequency > 0:
+            turns_counter = self.group_manager.bump_turns_counter(group_id=self.group.id, actor=self.actor)
+
+        # Perform participant steps
+        if self.group.sleeptime_agent_frequency is None or (
+            turns_counter is not None and turns_counter % self.group.sleeptime_agent_frequency == 0
+        ):
+            last_processed_message_id = self.group_manager.get_last_processed_message_id_and_update(
+                group_id=self.group.id, last_processed_message_id=last_response_messages[-1].id, actor=self.actor
+            )
+            for sleeptime_agent_id in self.group.agent_ids:
+                self._issue_background_task(
+                    sleeptime_agent_id,
+                    last_response_messages,
+                    last_processed_message_id,
+                )
+
+    async def _issue_background_task(
+        self,
+        sleeptime_agent_id: str,
+        response_messages: List[Message],
+        last_processed_message_id: str,
+    ) -> str:
+        run = Run(
+            user_id=self.actor.id,
+            status=JobStatus.created,
+            metadata={
+                "job_type": "sleeptime_agent_send_message_async",  # is this right?
+                "agent_id": sleeptime_agent_id,
+            },
+        )
+        run = self.job_manager.create_job(pydantic_job=run, actor=self.actor)
+
+        asyncio.create_task(
+            self._participant_agent_step(
+                foreground_agent_id=self.agent_id,
+                sleeptime_agent_id=sleeptime_agent_id,
+                response_messages=response_messages,
+                last_processed_message_id=last_processed_message_id,
+                run_id=run.id,
+            )
+        )
+        return run.id
+
+    async def _participant_agent_step(
+        self,
+        foreground_agent_id: str,
+        sleeptime_agent_id: str,
+        response_messages: List[Message],
+        last_processed_message_id: str,
+        run_id: str,
+    ) -> str:
+        try:
+            # Update job status
+            job_update = JobUpdate(status=JobStatus.running)
+            self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.actor)
+
+            # Create conversation transcript
+            prior_messages = []
+            if self.group.sleeptime_agent_frequency:
+                try:
+                    prior_messages = self.message_manager.list_messages_for_agent(
+                        agent_id=foreground_agent_id,
+                        actor=self.actor,
+                        after=last_processed_message_id,
+                        before=response_messages[0].id,
+                    )
+                except Exception:
+                    pass  # continue with just latest messages
+
+            transcript_summary = [stringify_message(message) for message in prior_messages + response_messages]
+            transcript_summary = [summary for summary in transcript_summary if summary is not None]
+            message_text = "\n".join(transcript_summary)
+
+            sleeptime_agent_messages = [
+                MessageCreate(
+                    role="user",
+                    content=[TextContent(text=message_text)],
+                    id=Message.generate_id(),
+                    agent_id=sleeptime_agent_id,
+                    group_id=self.group.id,
+                )
+            ]
+
+            # Load sleeptime agent
+            sleeptime_agent = LettaAgent(
+                agent_id=sleeptime_agent_id,
+                message_manager=self.message_manager,
+                agent_manager=self.agent_manager,
+                block_manager=self.block_manager,
+                passage_manager=self.passage_manager,
+                actor=self.actor,
+            )
+
+            # Perform sleeptime agent step
+            result = await sleeptime_agent.step(
+                input_messages=sleeptime_agent_messages,
+            )
+
+            # Update job status
+            job_update = JobUpdate(
+                status=JobStatus.completed,
+                completed_at=datetime.now(timezone.utc),
+                metadata={
+                    "result": result.model_dump(mode="json"),
+                    "agent_id": sleeptime_agent_id,
+                },
+            )
+            self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.actor)
+            return result
+        except Exception as e:
+            job_update = JobUpdate(
+                status=JobStatus.failed,
+                completed_at=datetime.now(timezone.utc),
+                metadata={"error": str(e)},
+            )
+            self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.actor)
+            raise

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/server/rest_api/routers/v1/__init__.py

@@ -1,5 +1,6 @@
 from letta.server.rest_api.routers.v1.agents import router as agents_router
 from letta.server.rest_api.routers.v1.blocks import router as blocks_router
+from letta.server.rest_api.routers.v1.embeddings import router as embeddings_router
 from letta.server.rest_api.routers.v1.groups import router as groups_router
 from letta.server.rest_api.routers.v1.health import router as health_router
 from letta.server.rest_api.routers.v1.identities import router as identities_router
@@ -32,4 +33,5 @@ ROUTERS = [
     tags_router,
     messages_router,
     voice_router,
+    embeddings_router,
 ]

letta_nightly-0.7.5.dev20250428110034/letta/server/rest_api/routers/v1/embeddings.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from fastapi import APIRouter, Depends, Header
+
+from letta.server.rest_api.utils import get_letta_server
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/embeddings", tags=["embeddings"])
+
+
+@router.get("/total_storage_size", response_model=float, operation_id="get_total_storage_size")
+def get_embeddings_storage_size(
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Get the total size of all embeddings in the database for a user in GB.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    return server.passage_manager.estimate_embeddings_size_GB(actor=actor)

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/server/rest_api/routers/v1/llms.py

@@ -13,7 +13,7 @@ router = APIRouter(prefix="/models", tags=["models", "llms"])
 
 
 @router.get("/", response_model=List[LLMConfig], operation_id="list_models")
-def list_llm_backends(
+def list_llm_models(
     server: "SyncServer" = Depends(get_letta_server),
 ):
 
@@ -23,7 +23,7 @@ def list_llm_backends(
 
 
 @router.get("/embedding", response_model=List[EmbeddingConfig], operation_id="list_embedding_models")
-def list_embedding_backends(
+def list_embedding_models(
     server: "SyncServer" = Depends(get_letta_server),
 ):
 

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/server/rest_api/routers/v1/sources.py

@@ -20,6 +20,17 @@ from letta.utils import sanitize_filename
 router = APIRouter(prefix="/sources", tags=["sources"])
 
 
+@router.get("/count", response_model=int, operation_id="count_sources")
+def count_sources(
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Count all data sources created by a user.
+    """
+    return server.source_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+
+
 @router.get("/{source_id}", response_model=Source, operation_id="retrieve_source")
 def retrieve_source(
     source_id: str,

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/server/rest_api/routers/v1/tools.py

@@ -9,7 +9,7 @@ from composio.exceptions import (
     EnumMetadataNotFound,
     EnumStringNotFound,
 )
-from fastapi import APIRouter, Body, Depends, Header, HTTPException
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
 from letta.errors import LettaToolCreateError
 from letta.functions.mcp_client.exceptions import MCPTimeoutError
@@ -40,6 +40,24 @@ def delete_tool(
     server.tool_manager.delete_tool_by_id(tool_id=tool_id, actor=actor)
 
 
+@router.get("/count", response_model=int, operation_id="count_tools")
+def count_tools(
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    include_base_tools: Optional[bool] = Query(False, description="Include built-in Letta tools in the count"),
+):
+    """
+    Get a count of all tools available to agents belonging to the org of the user.
+    """
+    try:
+        return server.tool_manager.size(
+            actor=server.user_manager.get_user_or_default(user_id=actor_id), include_base_tools=include_base_tools
+        )
+    except Exception as e:
+        print(f"Error occurred: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @router.get("/{tool_id}", response_model=Tool, operation_id="retrieve_tool")
 def retrieve_tool(
     tool_id: str,

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/services/passage_manager.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 
 from openai import OpenAI
 
+from letta.constants import MAX_EMBEDDING_DIM
 from letta.embeddings import embedding_model, parse_and_chunk_text
 from letta.orm.errors import NoResultFound
 from letta.orm.passage import AgentPassage, SourcePassage
@@ -218,3 +219,16 @@ class PassageManager:
         """
         with self.session_maker() as session:
             return AgentPassage.size(db_session=session, actor=actor, agent_id=agent_id)
+
+    def estimate_embeddings_size_GB(
+        self,
+        actor: PydanticUser,
+        agent_id: Optional[str] = None,
+    ) -> float:
+        """
+        Estimate the size of the embeddings in GB.
+        """
+        BYTES_PER_EMBEDDING_DIM = 4
+        BYTES_PER_GB = 1024 * 1024 * 1024
+        GB_PER_EMBEDDING = BYTES_PER_EMBEDDING_DIM / BYTES_PER_GB * MAX_EMBEDDING_DIM
+        return self.size(actor=actor, agent_id=agent_id) * GB_PER_EMBEDDING

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/services/tool_executor/tool_executor.py

@@ -192,7 +192,7 @@ class LettaCoreToolExecutor(ToolExecutor):
         AgentManager().rebuild_system_prompt(agent_id=agent_state.id, actor=actor, force=True)
         return None
 
-    def core_memory_append(self, agent_state: "AgentState", actor: User, label: str, content: str) -> Optional[str]:
+    def core_memory_append(self, agent_state: AgentState, actor: User, label: str, content: str) -> Optional[str]:
         """
         Append to the contents of core memory.
 
@@ -211,7 +211,7 @@ class LettaCoreToolExecutor(ToolExecutor):
 
     def core_memory_replace(
         self,
-        agent_state: "AgentState",
+        agent_state: AgentState,
         actor: User,
         label: str,
         old_content: str,
@@ -237,7 +237,8 @@ class LettaCoreToolExecutor(ToolExecutor):
         return None
 
     def memory_replace(
-        agent_state: "AgentState",
+        self,
+        agent_state: AgentState,
         actor: User,
         label: str,
         old_str: str,
@@ -326,7 +327,8 @@ class LettaCoreToolExecutor(ToolExecutor):
         return success_msg
 
     def memory_insert(
-        agent_state: "AgentState",
+        self,
+        agent_state: AgentState,
         actor: User,
         label: str,
         new_str: str,
@@ -407,7 +409,7 @@ class LettaCoreToolExecutor(ToolExecutor):
 
         return success_msg
 
-    def memory_rethink(agent_state: "AgentState", actor: User, label: str, new_memory: str) -> str:
+    def memory_rethink(self, agent_state: AgentState, actor: User, label: str, new_memory: str) -> str:
         """
         The memory_rethink command allows you to completely rewrite the contents of a
         memory block. Use this tool to make large sweeping changes (e.g. when you want
@@ -458,7 +460,7 @@ class LettaCoreToolExecutor(ToolExecutor):
         # return None
         return success_msg
 
-    def memory_finish_edits(agent_state: "AgentState") -> None:
+    def memory_finish_edits(self, agent_state: AgentState, actor: User) -> None:
         """
         Call the memory_finish_edits command when you are finished making edits
         (integrating all new information) into the memory blocks. This function

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/letta/services/tool_manager.py

@@ -29,14 +29,6 @@ logger = get_logger(__name__)
 class ToolManager:
     """Manager class to handle business logic related to Tools."""
 
-    BASE_TOOL_NAMES = [
-        "send_message",
-        "conversation_search",
-        "archival_memory_insert",
-        "archival_memory_search",
-    ]
-    BASE_MEMORY_TOOL_NAMES = ["core_memory_append", "core_memory_replace"]
-
     def __init__(self):
         # Fetching the db_context similarly as in OrganizationManager
         from letta.server.db import db_context
@@ -149,12 +141,17 @@ class ToolManager:
     def size(
         self,
         actor: PydanticUser,
+        include_base_tools: bool,
     ) -> int:
         """
         Get the total count of tools for the given user.
+
+        If include_builtin is True, it will also count the built-in tools.
         """
         with self.session_maker() as session:
-            return ToolModel.size(db_session=session, actor=actor)
+            if include_base_tools:
+                return ToolModel.size(db_session=session, actor=actor)
+            return ToolModel.size(db_session=session, actor=actor, name=LETTA_TOOL_SET)
 
     @enforce_types
     def update_tool_by_id(self, tool_id: str, tool_update: ToolUpdate, actor: PydanticUser) -> PydanticTool:

{letta_nightly-0.7.5.dev20250426104040 → letta_nightly-0.7.5.dev20250428110034}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.7.5.dev20250426104040"
+version = "0.7.5.dev20250428110034"
 packages = [
     {include = "letta"},
 ]