letta-nightly 0.7.5.dev20250426104040__py3-none-any.whl → 0.7.5.dev20250428110034__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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.dist-info → letta_nightly-0.7.5.dev20250428110034.dist-info}/METADATA

@@ -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.dist-info → letta_nightly-0.7.5.dev20250428110034.dist-info}/RECORD

@@ -6,7 +6,7 @@ letta/agents/base_agent.py,sha256=yjB1Yz6L-9hTFinqkvyf6c-8dDX9O4u8VCrKrvA4G3s,23
 letta/agents/ephemeral_agent.py,sha256=el-SUF_16vv_7OouIR-6z0pAE9Yc0PLibygvfCKwqfo,2736
 letta/agents/ephemeral_memory_agent.py,sha256=tVRsL18EvruNyrhzPkzLqiptfWa9jAC2GmSjUf5zKQo,4821
 letta/agents/helpers.py,sha256=sYfjJLCEQg0aaKDRIJ2Xm_fG1yivCB9wU6bSskZMPKg,2568
-letta/agents/letta_agent.py,sha256=9kOJW8hU_UhRwaVujYBWxVxsOGbh367xfdymI81RdNI,17816
+letta/agents/letta_agent.py,sha256=Y_hqJjFcFnVU2-kdbMmtKYp4l9_yCXeHCjvo8qqI1gU,18162
 letta/agents/letta_agent_batch.py,sha256=YsuYKwanRAmSPwmT5NVG3oIyOjlOz08hrQgpgRNhXt0,22899
 letta/agents/voice_agent.py,sha256=qzDw7MWQYwxsqOT4nIJ9OSl72n7b2Xy3ZUqc2_AEP5M,17334
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
@@ -40,9 +40,10 @@ letta/functions/mcp_client/stdio_client.py,sha256=2oouLGphu4S15OrYj97n9_ZYZo-GMR
 letta/functions/mcp_client/types.py,sha256=nmcnQn2EpxXzXg5_pWPsHZobfxO6OucaUgz1bVvam7o,1411
 letta/functions/schema_generator.py,sha256=OoXDHd5oZMNjljZJplEIMOMmKvxO_rfDFtAi-E9EHMA,22488
 letta/groups/dynamic_multi_agent.py,sha256=OLCxhICFLYyx8wjKGPr1INc6pniEuk4YGZyZhq2vkiY,12230
-letta/groups/helpers.py,sha256=Cof7vfZMOT2gApYpROpiAyKSKrofP1UPJxZQWFcZaqA,4336
+letta/groups/helpers.py,sha256=pfvwIia27wKWBgWjhN12DLkHRfzNw6R9nSBZrrPEmx4,4459
 letta/groups/round_robin_multi_agent.py,sha256=uUJff0bO68udOREiKFWeS7eEQlk3bF7hcfLSFXMScqI,6999
-letta/groups/sleeptime_multi_agent.py,sha256=aGtL7YiCcy1pjEXHNf85to8Wa2AT4m47Su4qXSmP3Pg,10054
+letta/groups/sleeptime_multi_agent.py,sha256=yfi78hnCZ24Alux95dHE6s8JvlLR9LjHqKpRf7Rvpic,10217
+letta/groups/sleeptime_multi_agent_v2.py,sha256=MPOjB8LMAW1R2SAEZC9TIOk12nWqEPzMp_80t8cF1Wg,10064
 letta/groups/supervisor_multi_agent.py,sha256=ml8Gi9gyVjPuVZjAJAkpGZDjnM7GOS50NkKf5SIutvQ,4455
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
 letta/helpers/composio_helpers.py,sha256=5SznD1Y0Y1rV4_wu-uCaZdDU2tNedk-RIX0M9-0r6yo,947
@@ -257,23 +258,24 @@ letta/server/rest_api/optimistic_json_parser.py,sha256=SS60lTp1oH2MXbHOChEnNm46x
 letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=Ksh_F6hJDOrafY2Gxz7NQdQZXBNeX-3-w4mVEQgMhrQ,5327
-letta/server/rest_api/routers/v1/__init__.py,sha256=M-L-Ls4rQaVyQvMjFNEu3NhcRLCvsbOKI-l7F4JxifQ,1557
+letta/server/rest_api/routers/v1/__init__.py,sha256=_skmAcDOK9ovHKfywRaBgigo3IvPmnUSQSR2hGVCOhY,1664
 letta/server/rest_api/routers/v1/agents.py,sha256=3mbPzEKBCzJmpUBUmJrs1WbmkIGTjEJ32HNUb1Lo5_M,34676
 letta/server/rest_api/routers/v1/blocks.py,sha256=Sefvon0jLvlNh0oAzntUcDZptnutuJOf-2Wcad_45Dg,4169
+letta/server/rest_api/routers/v1/embeddings.py,sha256=jtfZkffCDnIfPqu9-fVLu7j3rpTOl_IuTIwJ0HQCkMA,786
 letta/server/rest_api/routers/v1/groups.py,sha256=sLXkw8kgf9fhaQwb-n0SVbyzH6-e1kdzNuqGbdvPPgo,10890
 letta/server/rest_api/routers/v1/health.py,sha256=MoOjkydhGcJXTiuJrKIB0etVXiRMdTa51S8RQ8-50DQ,399
 letta/server/rest_api/routers/v1/identities.py,sha256=fvp-0cwvb4iX1fUGPkL--9nq8YD3tIE47kYRxUgOlp4,7462
 letta/server/rest_api/routers/v1/jobs.py,sha256=4oeJfI2odNGubU_g7WSORJhn_usFsbRaD-qm86rve1E,2746
-letta/server/rest_api/routers/v1/llms.py,sha256=lYp5URXtZk1yu_Pe-p1Wq1uQ0qeb6aWtx78rXSB7N_E,881
+letta/server/rest_api/routers/v1/llms.py,sha256=-3VBkh4vUJvrldLy2ptRnexb33psa1zPHaLiQ812xyE,877
 letta/server/rest_api/routers/v1/messages.py,sha256=3hfaiiCBiWr-wub_uzr3Vyh4IBTZYwGqeDG-2h6Xlus,5753
 letta/server/rest_api/routers/v1/organizations.py,sha256=r7rj-cA3shgAgM0b2JCMqjYsDIFv3ruZjU7SYbPGGqg,2831
 letta/server/rest_api/routers/v1/providers.py,sha256=MVfAUvXj_2jx8XFwSigM-8CuCfEATW60h8J5UEmAhp0,3146
 letta/server/rest_api/routers/v1/runs.py,sha256=9nuJRjBtRgZPq3CiCEUA_3S2xPHFP5DsJxIenH5OO34,8847
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=9hqnnMwJ3wCwO-Bezu3Xl8i3TDSIuInw3gSeHaKUXfE,8526
-letta/server/rest_api/routers/v1/sources.py,sha256=U9cf7DlqKAvXgNnmyOvr2XLBHiJbimFCQw__gV__HV8,10709
+letta/server/rest_api/routers/v1/sources.py,sha256=7cCcgZm9AtUFaWlMcyovC-7f_eNhJa4EcDkZuQbNJo8,11148
 letta/server/rest_api/routers/v1/steps.py,sha256=DVVwaxLNbNAgWpr2oQkrNjdS-wi0bP8kVJZUO-hiaf8,3275
 letta/server/rest_api/routers/v1/tags.py,sha256=coydgvL6-9cuG2Hy5Ea7QY3inhTHlsf69w0tcZenBus,880
-letta/server/rest_api/routers/v1/tools.py,sha256=vDDhG25vQOz3y12XN_dayh4OweW1rjaLHxZJuJgZkQA,18821
+letta/server/rest_api/routers/v1/tools.py,sha256=FXFx8J4Zs-pZ1H8andFzI5Pyv-PJkY8YMlWkZlObGdQ,19544
 letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQczIq2Z3YLdbVo,2277
 letta/server/rest_api/routers/v1/voice.py,sha256=0lerWjrKLkt4gXLhZl1cIcgstOz9Q2HZwc67L58BCXE,2451
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
@@ -307,7 +309,7 @@ letta/services/mcp/stdio_client.py,sha256=wdPzTqSRkibjt9pXhwi0Nul_z_cTAPim-OHjLc
 letta/services/mcp/types.py,sha256=nmcnQn2EpxXzXg5_pWPsHZobfxO6OucaUgz1bVvam7o,1411
 letta/services/message_manager.py,sha256=iRFFu7WP9GBtGKrQp5Igiqp_wonSfRKZ_Ran5X6SZZA,17946
 letta/services/organization_manager.py,sha256=Ax0KmPSc_YYsYaxeld9gc7ST-J6DemHQ542DD7l7AWA,3989
-letta/services/passage_manager.py,sha256=KY18gHTbx8ROBsOeR7ZAefTMGZwzbxYqOjbadqVFiyQ,9121
+letta/services/passage_manager.py,sha256=4ALhe4lDdLiGQptBXdvonQ9Sv4SpNSI5TlmQ_1TRfeU,9619
 letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1HVEAhXsAg9-4,546
 letta/services/provider_manager.py,sha256=_gEBW0tYIf2vJEGGYxk-nvogrFI9sjFl_97MSL5WC2s,3759
 letta/services/sandbox_config_manager.py,sha256=ATgZNWNpkdIQDUPy4ABsguHQba2PZf51-c4Ji60MzLE,13361
@@ -319,8 +321,8 @@ letta/services/summarizer/summarizer.py,sha256=4rbbzcB_lY4-3ybT8HMxM8OskLC38YCs9
 letta/services/tool_executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tool_executor/tool_execution_manager.py,sha256=RcmnwPougb8AxIwKdC4N9ZxTvOQqJyjI6CaVHF2HBi4,4505
 letta/services/tool_executor/tool_execution_sandbox.py,sha256=hu-SVqfRalJGcXRKTpbYkqgX-DZH3Uky_eD_vh0kx6s,24704
-letta/services/tool_executor/tool_executor.py,sha256=keWIzQuwqSzcC6kWcbTY_SfclhKtOT5CZNE-r3OBWNk,27372
-letta/services/tool_manager.py,sha256=lFnQkgBYXAXl9q_8_TqJX_UZtLTATXmPliCdm8_7K8M,10561
+letta/services/tool_executor/tool_executor.py,sha256=k2yEzLpU18SFFA6NWrf5NYbCh505ixMpnf6pnBhmV8s,27413
+letta/services/tool_manager.py,sha256=ZtDRk9IODlMSJgwAzI1RQVee0fqgFzNu8iFZ92qwm-c,10569
 letta/services/tool_sandbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tool_sandbox/base.py,sha256=pUnPFkEg9I5ktMuT4AOOxbTnTmZTGcTA2phLe1H1EdY,8306
 letta/services/tool_sandbox/e2b_sandbox.py,sha256=umsXfolzM_j67izswECDdVfnlcm03wLpMoZtS6SZ0sc,6147
@@ -332,8 +334,8 @@ letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,1194
 letta/system.py,sha256=dnOrS2FlRMwijQnOvfrky0Lg8wEw-FUq2zzfAJOUSKA,8477
 letta/tracing.py,sha256=RstWXpfWVF77nmb_ISORVWd9IQw2Ky3de40k_S70yKI,8258
 letta/utils.py,sha256=IZFvtj9WYcrxUbkoUUYGDxMYQYdn5SgfqsvnARGsAzc,32245
-letta_nightly-0.7.5.dev20250426104040.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.7.5.dev20250426104040.dist-info/METADATA,sha256=LFjhA8EEQOWmWwIneP1zo--Cw9iML8p8MSUAxXUYVjw,22282
-letta_nightly-0.7.5.dev20250426104040.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.7.5.dev20250426104040.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.7.5.dev20250426104040.dist-info/RECORD,,
+letta_nightly-0.7.5.dev20250428110034.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.7.5.dev20250428110034.dist-info/METADATA,sha256=hhRpH0hsiMPeGsUc0483f3XtXyn3aMImulVCkpOdv6A,22282
+letta_nightly-0.7.5.dev20250428110034.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.7.5.dev20250428110034.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.7.5.dev20250428110034.dist-info/RECORD,,