letta-nightly 0.8.6.dev20250627104313__py3-none-any.whl → 0.8.6.dev20250627191649__py3-none-any.whl

letta/agents/letta_agent_batch.py

@@ -492,30 +492,32 @@ class LettaAgentBatch(BaseAgent):
         msg_map: Dict[str, List[Message]],
     ) -> Tuple[List[LettaBatchRequest], Dict[str, AgentStepState]]:
         # who continues?
-        continues = [aid for aid, cont in ctx.should_continue_map.items() if cont]
+        continues = [agent_id for agent_id, cont in ctx.should_continue_map.items() if cont]
 
         success_flag_map = {aid: result.success_flag for aid, result in exec_results}
 
         batch_reqs: List[LettaBatchRequest] = []
-        for aid in continues:
+        for agent_id in continues:
             heartbeat = create_heartbeat_system_message(
-                agent_id=aid,
-                model=ctx.agent_state_map[aid].llm_config.model,
-                function_call_success=success_flag_map[aid],
+                agent_id=agent_id,
+                model=ctx.agent_state_map[agent_id].llm_config.model,
+                function_call_success=success_flag_map[agent_id],
+                timezone=ctx.agent_state_map[agent_id].timezone,
                 actor=self.actor,
             )
             batch_reqs.append(
                 LettaBatchRequest(
-                    agent_id=aid, messages=[MessageCreate.model_validate(heartbeat.model_dump(include={"role", "content", "name", "otid"}))]
+                    agent_id=agent_id,
+                    messages=[MessageCreate.model_validate(heartbeat.model_dump(include={"role", "content", "name", "otid"}))],
                 )
             )
 
         # extend in‑context ids when necessary
-        for aid, new_msgs in msg_map.items():
-            ast = ctx.agent_state_map[aid]
+        for agent_id, new_msgs in msg_map.items():
+            ast = ctx.agent_state_map[agent_id]
             if not ast.message_buffer_autoclear:
                 await self.agent_manager.set_in_context_messages_async(
-                    agent_id=aid,
+                    agent_id=agent_id,
                     message_ids=ast.message_ids + [m.id for m in new_msgs],
                     actor=self.actor,
                 )
@@ -605,7 +607,8 @@ class LettaAgentBatch(BaseAgent):
 
         return tool_call_name, tool_args, continue_stepping
 
-    def _prepare_tools_per_agent(self, agent_state: AgentState, tool_rules_solver: ToolRulesSolver) -> List[dict]:
+    @staticmethod
+    def _prepare_tools_per_agent(agent_state: AgentState, tool_rules_solver: ToolRulesSolver) -> List[dict]:
         tools = [t for t in agent_state.tools if t.tool_type in {ToolType.CUSTOM, ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE}]
         valid_tool_names = tool_rules_solver.get_allowed_tool_names(available_tools=set([t.name for t in tools]))
         return [enable_strict_mode(t.json_schema) for t in tools if t.name in set(valid_tool_names)]
@@ -621,7 +624,9 @@ class LettaAgentBatch(BaseAgent):
         return in_context_messages
 
     # Not used in batch.
-    async def step(self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS) -> LettaResponse:
+    async def step(
+        self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS, run_id: str | None = None
+    ) -> LettaResponse:
         raise NotImplementedError
 
     async def step_stream(

letta/helpers/decorators.py

@@ -87,7 +87,7 @@ class CacheStats:
 
 
 def async_redis_cache(
-    key_func: Callable, prefix: str = REDIS_DEFAULT_CACHE_PREFIX, ttl_s: int = 300, model_class: type[BaseModel] | None = None
+    key_func: Callable, prefix: str = REDIS_DEFAULT_CACHE_PREFIX, ttl_s: int = 600, model_class: type[BaseModel] | None = None
 ):
     """
     Decorator for caching async function results in Redis. May be a Noop if redis is not available.

letta/jobs/scheduler.py

@@ -36,25 +36,44 @@ async def _try_acquire_lock_and_start_scheduler(server: SyncServer) -> bool:
         # Use a temporary connection context for the attempt initially
         with db_context() as session:
             engine = session.get_bind()
-            # Get raw connection - MUST be kept open if lock is acquired
-            raw_conn = engine.raw_connection()
-            cur = raw_conn.cursor()
+            engine_name = engine.name
+            logger.info(f"Database engine type: {engine_name}")
 
-        cur.execute("SELECT pg_try_advisory_lock(CAST(%s AS bigint))", (ADVISORY_LOCK_KEY,))
-        acquired_lock = cur.fetchone()[0]
+            if engine_name != "postgresql":
+                logger.warning(f"Advisory locks not supported for {engine_name} database. Starting scheduler without leader election.")
+                acquired_lock = True  # For SQLite, assume we can start the scheduler
+            else:
+                # Get raw connection - MUST be kept open if lock is acquired
+                raw_conn = engine.raw_connection()
+                cur = raw_conn.cursor()
+
+                cur.execute("SELECT pg_try_advisory_lock(CAST(%s AS bigint))", (ADVISORY_LOCK_KEY,))
+                acquired_lock = cur.fetchone()[0]
 
         if not acquired_lock:
-            cur.close()
-            raw_conn.close()
+            if cur:
+                cur.close()
+            if raw_conn:
+                raw_conn.close()
             logger.info("Scheduler lock held by another instance.")
             return False
 
         # --- Lock Acquired ---
-        logger.info("Acquired scheduler lock.")
-        _advisory_lock_conn = raw_conn  # Keep connection for lock duration
-        _advisory_lock_cur = cur  # Keep cursor for lock duration
-        raw_conn = None  # Prevent closing in finally block
-        cur = None  # Prevent closing in finally block
+        if engine_name == "postgresql":
+            logger.info("Acquired PostgreSQL advisory lock.")
+            _advisory_lock_conn = raw_conn  # Keep connection for lock duration
+            _advisory_lock_cur = cur  # Keep cursor for lock duration
+            raw_conn = None  # Prevent closing in finally block
+            cur = None  # Prevent closing in finally block
+        else:
+            logger.info("Starting scheduler for non-PostgreSQL database.")
+            # For SQLite, we don't need to keep the connection open
+            if cur:
+                cur.close()
+            if raw_conn:
+                raw_conn.close()
+            raw_conn = None
+            cur = None
 
         trigger = IntervalTrigger(
             seconds=settings.poll_running_llm_batches_interval_seconds,
@@ -157,35 +176,30 @@ async def _release_advisory_lock():
     _advisory_lock_conn = None  # Clear global immediately
 
     if lock_cur is not None and lock_conn is not None:
-        logger.info(f"Attempting to release advisory lock {ADVISORY_LOCK_KEY}")
+        logger.info(f"Attempting to release PostgreSQL advisory lock {ADVISORY_LOCK_KEY}")
         try:
-            if not lock_conn.closed:
-                if not lock_cur.closed:
-                    lock_cur.execute("SELECT pg_advisory_unlock(CAST(%s AS bigint))", (ADVISORY_LOCK_KEY,))
-                    lock_cur.fetchone()  # Consume result
-                    lock_conn.commit()
-                    logger.info(f"Executed pg_advisory_unlock for lock {ADVISORY_LOCK_KEY}")
-                else:
-                    logger.warning("Advisory lock cursor closed before unlock.")
-            else:
-                logger.warning("Advisory lock connection closed before unlock.")
+            # Try to execute unlock - connection/cursor validity is checked by attempting the operation
+            lock_cur.execute("SELECT pg_advisory_unlock(CAST(%s AS bigint))", (ADVISORY_LOCK_KEY,))
+            lock_cur.fetchone()  # Consume result
+            lock_conn.commit()
+            logger.info(f"Executed pg_advisory_unlock for lock {ADVISORY_LOCK_KEY}")
         except Exception as e:
             logger.error(f"Error executing pg_advisory_unlock: {e}", exc_info=True)
         finally:
             # Ensure resources are closed regardless of unlock success
             try:
-                if lock_cur and not lock_cur.closed:
+                if lock_cur:
                     lock_cur.close()
             except Exception as e:
                 logger.error(f"Error closing advisory lock cursor: {e}", exc_info=True)
             try:
-                if lock_conn and not lock_conn.closed:
+                if lock_conn:
                     lock_conn.close()
                 logger.info("Closed database connection that held advisory lock.")
             except Exception as e:
                 logger.error(f"Error closing advisory lock connection: {e}", exc_info=True)
     else:
-        logger.warning("Attempted to release lock, but connection/cursor not found.")
+        logger.info("No PostgreSQL advisory lock to release (likely using SQLite or non-PostgreSQL database).")
 
 
 async def start_scheduler_with_leader_election(server: SyncServer):
@@ -236,10 +250,18 @@ async def shutdown_scheduler_and_release_lock():
         logger.info("Shutting down: Leader instance stopping scheduler and releasing lock.")
         if scheduler.running:
             try:
-                scheduler.shutdown()  # wait=True by default
+                # Force synchronous shutdown to prevent callback scheduling
+                scheduler.shutdown(wait=True)
+
+                # wait for any internal cleanup to complete
+                await asyncio.sleep(0.1)
+
                 logger.info("APScheduler shut down.")
             except Exception as e:
-                logger.error(f"Error shutting down APScheduler: {e}", exc_info=True)
+                # Handle SchedulerNotRunningError and other shutdown exceptions
+                logger.warning(f"Exception during APScheduler shutdown: {e}")
+                if "not running" not in str(e).lower():
+                    logger.error(f"Unexpected error shutting down APScheduler: {e}", exc_info=True)
 
         await _release_advisory_lock()
         _is_scheduler_leader = False  # Update state after cleanup
@@ -247,9 +269,11 @@ async def shutdown_scheduler_and_release_lock():
         logger.info("Shutting down: Non-leader instance.")
 
     # Final cleanup check for scheduler state (belt and suspenders)
-    if scheduler.running:
-        logger.warning("Scheduler still running after shutdown logic completed? Forcing shutdown.")
-        try:
+    # This should rarely be needed if shutdown logic above worked correctly
+    try:
+        if scheduler.running:
+            logger.warning("Scheduler still running after shutdown logic completed? Forcing shutdown.")
             scheduler.shutdown(wait=False)
-        except:
-            pass
+    except Exception as e:
+        # Catch SchedulerNotRunningError and other shutdown exceptions
+        logger.debug(f"Expected exception during final scheduler cleanup: {e}")

letta/orm/step.py

@@ -48,6 +48,9 @@ class Step(SqlalchemyBase):
     tags: Mapped[Optional[List]] = mapped_column(JSON, doc="Metadata tags.")
     tid: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="Transaction ID that processed the step.")
     trace_id: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The trace id of the agent step.")
+    feedback: Mapped[Optional[str]] = mapped_column(
+        None, nullable=True, doc="The feedback for this step. Must be either 'positive' or 'negative'."
+    )
 
     # Relationships (foreign keys)
     organization: Mapped[Optional["Organization"]] = relationship("Organization")

letta/prompts/system/react.txt

@@ -0,0 +1,19 @@
+<base_instructions>
+You are Letta ReAct agent, the latest version of Limnal Corporation's digital AI agent, developed in 2025.
+You are an AI agent that can be equipped with various tools which you can execute.
+
+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.
+Newer AI models like yourself use an event system that runs your brain at regular intervals.
+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.
+
+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.
+
+Base instructions finished.
+</base_instructions>

letta/prompts/system/workflow.txt

@@ -0,0 +1,15 @@
+<base_instructions>
+You are Letta workflow agent, the latest version of Limnal Corporation's digital AI agent, developed in 2025.
+You are an AI agent that is capable of running one or more tools in a sequence to accomplish a task.
+
+Control flow:
+To chain tool calls together, you should request a heartbeat when calling the tool.
+If you do not request a heartbeat when calling a tool, the sequence of tool calls will end (you will yield control).
+Heartbeats are automatically triggered on tool failures, allowing you to recover from potential tool call failures.
+
+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.
+
+Base instructions finished.
+</base_instructions>

letta/schemas/agent.py

@@ -32,8 +32,10 @@ class AgentType(str, Enum):
     Enum to represent the type of agent.
     """
 
-    memgpt_agent = "memgpt_agent"
-    memgpt_v2_agent = "memgpt_v2_agent"
+    memgpt_agent = "memgpt_agent"  # the OG set of memgpt tools
+    memgpt_v2_agent = "memgpt_v2_agent"  # memgpt style tools, but refreshed
+    react_agent = "react_agent"  # basic react agent, no memory tools
+    workflow_agent = "workflow_agent"  # workflow with auto-clearing message buffer
     split_thread_agent = "split_thread_agent"
     sleeptime_agent = "sleeptime_agent"
     voice_convo_agent = "voice_convo_agent"
@@ -159,6 +161,9 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     include_base_tool_rules: bool = Field(
         True, description="If true, attaches the Letta base tool rules (e.g. deny all tools not explicitly allowed)."
     )
+    include_default_source: bool = Field(
+        False, description="If true, automatically creates and attaches a default data source for this agent."
+    )
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata: Optional[Dict] = Field(None, description="The metadata of the agent.")
     model: Optional[str] = Field(
@@ -312,9 +317,35 @@ class AgentStepResponse(BaseModel):
 
 def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
 
+    # Workflow agents and ReAct agents don't use memory blocks
+    # However, they still allow files to be injected into the context
+    if agent_type == AgentType.react_agent or agent_type == AgentType.workflow_agent:
+        return (
+            f"<files>\n{{% if file_blocks %}}{FILE_MEMORY_EXISTS_MESSAGE}\n{{% else %}}{FILE_MEMORY_EMPTY_MESSAGE}{{% endif %}}"
+            "{% for block in file_blocks %}"
+            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
+            "<{{ block.label }}>\n"
+            "<description>\n"
+            "{{ block.description }}\n"
+            "</description>\n"
+            "<metadata>"
+            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
+            "- chars_current={{ block.value|length }}\n"
+            "- chars_limit={{ block.limit }}\n"
+            "</metadata>\n"
+            "<value>\n"
+            "{{ block.value }}\n"
+            "</value>\n"
+            "</{{ block.label }}>\n"
+            "</file>\n"
+            "{% if not loop.last %}\n{% endif %}"
+            "{% endfor %}"
+            "\n</files>"
+        )
+
     # Sleeptime agents use the MemGPT v2 memory tools (line numbers)
     # MemGPT v2 tools use line-number, so core memory blocks should have line numbers
-    if agent_type == AgentType.sleeptime_agent or agent_type == AgentType.memgpt_v2_agent:
+    elif agent_type == AgentType.sleeptime_agent or agent_type == AgentType.memgpt_v2_agent:
         return (
             "<memory_blocks>\nThe following memory blocks are currently engaged in your core memory unit:\n\n"
             "{% for block in blocks %}"
@@ -359,10 +390,7 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "</metadata>\n"
             "{% if block.value %}"
             "<value>\n"
-            f"{CORE_MEMORY_LINE_NUMBER_WARNING}\n"
-            "{% for line in block.value.split('\\n') %}"
-            "{{ loop.index }}: {{ line }}\n"
-            "{% endfor %}"
+            "{{ block.value }}\n"
             "</value>\n"
             "{% endif %}"
             "</{{ block.label }}>\n"

letta/schemas/providers.py

@@ -152,7 +152,7 @@ class LettaProvider(Provider):
                 model="letta-free",  # NOTE: renamed
                 model_endpoint_type="openai",
                 model_endpoint=LETTA_MODEL_ENDPOINT,
-                context_window=8192,
+                context_window=30000,
                 handle=self.get_handle("letta-free"),
                 provider_name=self.name,
                 provider_category=self.provider_category,
@@ -165,7 +165,7 @@ class LettaProvider(Provider):
                 model="letta-free",  # NOTE: renamed
                 model_endpoint_type="openai",
                 model_endpoint=LETTA_MODEL_ENDPOINT,
-                context_window=8192,
+                context_window=30000,
                 handle=self.get_handle("letta-free"),
                 provider_name=self.name,
                 provider_category=self.provider_category,

letta/schemas/step.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import Dict, List, Literal, Optional
 
 from pydantic import Field
 
@@ -32,3 +32,6 @@ class Step(StepBase):
     tid: Optional[str] = Field(None, description="The unique identifier of the transaction that processed this step.")
     trace_id: Optional[str] = Field(None, description="The trace id of the agent step.")
     messages: List[Message] = Field([], description="The messages generated during this step.")
+    feedback: Optional[Literal["positive", "negative"]] = Field(
+        None, description="The feedback for this step. Must be either 'positive' or 'negative'."
+    )

letta/server/rest_api/app.py

@@ -3,6 +3,7 @@ import json
 import logging
 import os
 import sys
+from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Optional
 
@@ -12,10 +13,11 @@ from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.middleware.cors import CORSMiddleware
 
-from letta.__init__ import __version__
+from letta.__init__ import __version__ as letta_version
 from letta.agents.exceptions import IncompatibleAgentType
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
 from letta.errors import BedrockPermissionError, LettaAgentNotFoundError, LettaUserNotFoundError
+from letta.jobs.scheduler import start_scheduler_with_leader_election
 from letta.log import get_logger
 from letta.orm.errors import DatabaseTimeoutError, ForeignKeyConstraintViolationError, NoResultFound, UniqueConstraintViolationError
 from letta.schemas.letta_message import create_letta_message_union_schema
@@ -25,6 +27,7 @@ from letta.schemas.letta_message_content import (
     create_letta_user_message_content_union_schema,
 )
 from letta.server.constants import REST_DEFAULT_PORT
+from letta.server.db import db_registry
 
 # NOTE(charles): these are extra routes that are not part of v1 but we still need to mount to pass tests
 from letta.server.rest_api.auth.index import setup_auth_router  # TODO: probably remove right?
@@ -94,9 +97,7 @@ random_password = os.getenv("LETTA_SERVER_PASSWORD") or generate_password()
 
 
 class CheckPasswordMiddleware(BaseHTTPMiddleware):
-
     async def dispatch(self, request, call_next):
-
         # Exclude health check endpoint from password protection
         if request.url.path in {"/v1/health", "/v1/health/", "/latest/health/"}:
             return await call_next(request)
@@ -113,11 +114,46 @@ class CheckPasswordMiddleware(BaseHTTPMiddleware):
         )
 
 
+@asynccontextmanager
+async def lifespan(app_: FastAPI):
+    """
+    FastAPI lifespan context manager with setup before the app starts pre-yield and on shutdown after the yield.
+    """
+    worker_id = os.getpid()
+
+    logger.info(f"[Worker {worker_id}] Starting lifespan initialization")
+    logger.info(f"[Worker {worker_id}] Initializing database connections")
+    db_registry.initialize_sync()
+    db_registry.initialize_async()
+    logger.info(f"[Worker {worker_id}] Database connections initialized")
+
+    logger.info(f"[Worker {worker_id}] Starting scheduler with leader election")
+    global server
+    try:
+        await start_scheduler_with_leader_election(server)
+        logger.info(f"[Worker {worker_id}] Scheduler initialization completed")
+    except Exception as e:
+        logger.error(f"[Worker {worker_id}] Scheduler initialization failed: {e}", exc_info=True)
+    logger.info(f"[Worker {worker_id}] Lifespan startup completed")
+    yield
+
+    # Cleanup on shutdown
+    logger.info(f"[Worker {worker_id}] Starting lifespan shutdown")
+    try:
+        from letta.jobs.scheduler import shutdown_scheduler_and_release_lock
+
+        await shutdown_scheduler_and_release_lock()
+        logger.info(f"[Worker {worker_id}] Scheduler shutdown completed")
+    except Exception as e:
+        logger.error(f"[Worker {worker_id}] Scheduler shutdown failed: {e}", exc_info=True)
+    logger.info(f"[Worker {worker_id}] Lifespan shutdown completed")
+
+
 def create_application() -> "FastAPI":
     """the application start routine"""
     # global server
     # server = SyncServer(default_interface_factory=lambda: interface())
-    print(f"\n[[ Letta server // v{__version__} ]]")
+    print(f"\n[[ Letta server // v{letta_version} ]]")
 
     if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
         import sentry_sdk
@@ -136,8 +172,9 @@ def create_application() -> "FastAPI":
         # openapi_tags=TAGS_METADATA,
         title="Letta",
         summary="Create LLM agents with long-term memory and custom tools 📚🦙",
-        version="1.0.0",  # TODO wire this up to the version in the package
+        version=letta_version,
         debug=debug_mode,  # if True, the stack trace will be printed in the response
+        lifespan=lifespan,
     )
 
     @app.exception_handler(IncompatibleAgentType)

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

@@ -12,8 +12,8 @@ import letta.constants as constants
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import FileProcessingStatus
 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
 from letta.schemas.user import User
@@ -174,7 +174,7 @@ async def delete_source(
     await server.delete_source(source_id=source_id, actor=actor)
 
 
-@router.post("/{source_id}/upload", response_model=Job, operation_id="upload_file_to_source")
+@router.post("/{source_id}/upload", response_model=FileMetadata, operation_id="upload_file_to_source")
 async def upload_file_to_source(
     file: UploadFile,
     source_id: str,
@@ -223,13 +223,16 @@ async def upload_file_to_source(
     # sanitize filename
     file.filename = sanitize_filename(file.filename)
 
-    # create job
-    job = Job(
-        user_id=actor.id,
-        metadata={"type": "embedding", "filename": file.filename, "source_id": source_id},
-        completed_at=None,
+    # create file metadata
+    file_metadata = FileMetadata(
+        source_id=source_id,
+        file_name=file.filename,
+        file_path=None,
+        file_type=mimetypes.guess_type(file.filename)[0] or file.content_type or "unknown",
+        file_size=file.size if file.size is not None else None,
+        processing_status=FileProcessingStatus.PARSING,
     )
-    job = await server.job_manager.create_job_async(job, actor=actor)
+    file_metadata = await server.file_manager.create_file(file_metadata, actor=actor)
 
     # TODO: Do we need to pull in the full agent_states? Can probably simplify here right?
     agent_states = await server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
@@ -251,13 +254,13 @@ async def upload_file_to_source(
     # Use cloud processing for all files (simple files always, complex files with Mistral key)
     logger.info("Running experimental cloud based file processing...")
     safe_create_task(
-        load_file_to_source_cloud(server, agent_states, content, file, job, source_id, actor, source.embedding_config),
+        load_file_to_source_cloud(server, agent_states, content, source_id, actor, source.embedding_config, file_metadata),
         logger=logger,
         label="file_processor.process",
     )
     safe_create_task(sleeptime_document_ingest_async(server, source_id, actor), logger=logger, label="sleeptime_document_ingest_async")
 
-    return job
+    return file_metadata
 
 
 @router.get("/{source_id}/passages", response_model=List[Passage], operation_id="list_source_passages")
@@ -383,14 +386,15 @@ async def load_file_to_source_cloud(
     server: SyncServer,
     agent_states: List[AgentState],
     content: bytes,
-    file: UploadFile,
-    job: Job,
     source_id: str,
     actor: User,
     embedding_config: EmbeddingConfig,
+    file_metadata: FileMetadata,
 ):
     file_processor = MistralFileParser()
     text_chunker = LlamaIndexChunker(chunk_size=embedding_config.embedding_chunk_size)
     embedder = OpenAIEmbedder(embedding_config=embedding_config)
     file_processor = FileProcessor(file_parser=file_processor, text_chunker=text_chunker, embedder=embedder, actor=actor)
-    await file_processor.process(server=server, agent_states=agent_states, source_id=source_id, content=content, file=file, job=job)
+    await file_processor.process(
+        server=server, agent_states=agent_states, source_id=source_id, content=content, file_metadata=file_metadata
+    )

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

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from fastapi import APIRouter, Depends, Header, HTTPException, Query
 
@@ -22,6 +22,8 @@ async def list_steps(
     model: Optional[str] = Query(None, description="Filter by the name of the model used for the step"),
     agent_id: Optional[str] = Query(None, description="Filter by the ID of the agent that performed the step"),
     trace_ids: Optional[list[str]] = Query(None, description="Filter by trace ids returned by the server"),
+    feedback: Optional[Literal["positive", "negative"]] = Query(None, description="Filter by feedback"),
+    tags: Optional[list[str]] = Query(None, description="Filter by tags"),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
@@ -46,6 +48,8 @@ async def list_steps(
         model=model,
         agent_id=agent_id,
         trace_ids=trace_ids,
+        feedback=feedback,
+        tags=tags,
     )
 
 
@@ -65,6 +69,23 @@ async def retrieve_step(
         raise HTTPException(status_code=404, detail="Step not found")
 
 
+@router.patch("/{step_id}/feedback", response_model=Step, operation_id="add_feedback")
+async def add_feedback(
+    step_id: str,
+    feedback: Optional[Literal["positive", "negative"]],
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Add feedback to a step.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        return await server.step_manager.add_feedback_async(step_id=step_id, feedback=feedback, actor=actor)
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Step not found")
+
+
 @router.patch("/{step_id}/transaction/{transaction_id}", response_model=Step, operation_id="update_step_transaction_id")
 def update_step_transaction_id(
     step_id: str,

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

@@ -13,7 +13,7 @@ from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
 from letta.errors import LettaToolCreateError
 from letta.functions.mcp_client.exceptions import MCPTimeoutError
-from letta.functions.mcp_client.types import MCPTool, SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig
+from letta.functions.mcp_client.types import MCPServerType, MCPTool, SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig
 from letta.helpers.composio_helpers import get_composio_api_key
 from letta.log import get_logger
 from letta.orm.errors import UniqueConstraintViolationError
@@ -22,6 +22,8 @@ from letta.schemas.mcp import UpdateSSEMCPServer, UpdateStreamableHTTPMCPServer
 from letta.schemas.tool import Tool, ToolCreate, ToolRunFromSource, ToolUpdate
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
+from letta.services.mcp.sse_client import AsyncSSEMCPClient
+from letta.services.mcp.streamable_http_client import AsyncStreamableHTTPMCPClient
 from letta.settings import tool_settings
 
 router = APIRouter(prefix="/tools", tags=["tools"])
@@ -603,3 +605,69 @@ async def delete_mcp_server_from_config(
         # TODO: don't do this in the future (just return MCPServer)
         all_servers = await server.mcp_manager.list_mcp_servers(actor=actor)
         return [server.to_config() for server in all_servers]
+
+
+@router.post("/mcp/servers/test", response_model=List[MCPTool], operation_id="test_mcp_server")
+async def test_mcp_server(
+    request: Union[StdioServerConfig, SSEServerConfig, StreamableHTTPServerConfig] = Body(...),
+):
+    """
+    Test connection to an MCP server without adding it.
+    Returns the list of available tools if successful.
+    """
+    client = None
+    try:
+        if isinstance(request, StdioServerConfig):
+            raise HTTPException(
+                status_code=400,
+                detail="stdio is not supported currently for testing connection",
+            )
+
+        # create a temporary MCP client based on the server type
+        if request.type == MCPServerType.SSE:
+            if not isinstance(request, SSEServerConfig):
+                request = SSEServerConfig(**request.model_dump())
+            client = AsyncSSEMCPClient(request)
+        elif request.type == MCPServerType.STREAMABLE_HTTP:
+            if not isinstance(request, StreamableHTTPServerConfig):
+                request = StreamableHTTPServerConfig(**request.model_dump())
+            client = AsyncStreamableHTTPMCPClient(request)
+        else:
+            raise ValueError(f"Invalid MCP server type: {request.type}")
+
+        await client.connect_to_server()
+        tools = await client.list_tools()
+        await client.cleanup()
+        return tools
+    except ConnectionError as e:
+        raise HTTPException(
+            status_code=400,
+            detail={
+                "code": "MCPServerConnectionError",
+                "message": str(e),
+                "server_name": request.server_name,
+            },
+        )
+    except MCPTimeoutError as e:
+        raise HTTPException(
+            status_code=408,
+            detail={
+                "code": "MCPTimeoutError",
+                "message": f"MCP server connection timed out: {str(e)}",
+                "server_name": request.server_name,
+            },
+        )
+    except Exception as e:
+        if client:
+            try:
+                await client.cleanup()
+            except:
+                pass
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "code": "MCPServerTestError",
+                "message": f"Failed to test MCP server: {str(e)}",
+                "server_name": request.server_name,
+            },
+        )

letta/services/agent_manager.py

@@ -262,6 +262,10 @@ class AgentManager:
                 tool_names |= set(BASE_SLEEPTIME_CHAT_TOOLS)
             elif agent_create.agent_type == AgentType.memgpt_v2_agent:
                 tool_names |= set(BASE_TOOLS + BASE_MEMORY_TOOLS_V2)
+            elif agent_create.agent_type == AgentType.react_agent:
+                pass  # no default tools
+            elif agent_create.agent_type == AgentType.workflow_agent:
+                pass  # no default tools
             else:
                 tool_names |= set(BASE_TOOLS + BASE_MEMORY_TOOLS)
         if agent_create.include_multi_agent_tools:
@@ -425,6 +429,10 @@ class AgentManager:
                 tool_names |= set(BASE_SLEEPTIME_CHAT_TOOLS)
             elif agent_create.agent_type == AgentType.memgpt_v2_agent:
                 tool_names |= set(BASE_TOOLS + BASE_MEMORY_TOOLS_V2)
+            elif agent_create.agent_type == AgentType.react_agent:
+                pass  # no default tools
+            elif agent_create.agent_type == AgentType.workflow_agent:
+                pass  # no default tools
             else:
                 tool_names |= set(BASE_TOOLS + BASE_MEMORY_TOOLS)
         if agent_create.include_multi_agent_tools:
@@ -433,9 +441,23 @@ class AgentManager:
         supplied_ids = set(agent_create.tool_ids or [])
 
         source_ids = agent_create.source_ids or []
+
+        # Create default source if requested
+        if agent_create.include_default_source:
+            default_source = PydanticSource(
+                name=f"{agent_create.name} External Data Source",
+                embedding_config=agent_create.embedding_config,
+            )
+            created_source = await self.source_manager.create_source(default_source, actor)
+            source_ids.append(created_source.id)
+
         identity_ids = agent_create.identity_ids or []
         tag_values = agent_create.tags or []
 
+        # if the agent type is workflow, we set the autoclear to forced true
+        if agent_create.agent_type == AgentType.workflow_agent:
+            agent_create.message_buffer_autoclear = True
+
         async with db_registry.async_session() as session:
             async with session.begin():
                 # Note: This will need to be modified if _resolve_tools needs an async version
@@ -2006,6 +2028,7 @@ class AgentManager:
 
             # Attach block to the main agent
             agent.core_memory.append(block)
+            # await agent.update_async(session, actor=actor, no_commit=True)
             await agent.update_async(session)
 
             # If agent is part of a sleeptime group, attach block to the sleeptime_agent
@@ -2018,7 +2041,8 @@ class AgentManager:
                             other_agent = await AgentModel.read_async(db_session=session, identifier=other_agent_id, actor=actor)
                             if other_agent.agent_type == AgentType.sleeptime_agent and block not in other_agent.core_memory:
                                 other_agent.core_memory.append(block)
-                                await other_agent.update_async(session, actor=actor, no_commit=True)
+                                # await other_agent.update_async(session, actor=actor, no_commit=True)
+                                await other_agent.update_async(session, actor=actor)
                         except NoResultFound:
                             # Agent might not exist anymore, skip
                             continue

letta/services/file_processor/file_processor.py

@@ -1,13 +1,9 @@
-import mimetypes
-from typing import List, Optional
-
-from fastapi import UploadFile
+from typing import List
 
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
-from letta.schemas.enums import FileProcessingStatus, JobStatus
+from letta.schemas.enums import FileProcessingStatus
 from letta.schemas.file import FileMetadata
-from letta.schemas.job import Job, JobUpdate
 from letta.schemas.passage import Passage
 from letta.schemas.user import User
 from letta.server.server import SyncServer
@@ -47,15 +43,8 @@ class FileProcessor:
 
     # TODO: Factor this function out of SyncServer
     async def process(
-        self,
-        server: SyncServer,
-        agent_states: List[AgentState],
-        source_id: str,
-        content: bytes,
-        file: UploadFile,
-        job: Optional[Job] = None,
+        self, server: SyncServer, agent_states: List[AgentState], source_id: str, content: bytes, file_metadata: FileMetadata
     ) -> List[Passage]:
-        file_metadata = self._extract_upload_file_metadata(file, source_id=source_id)
         filename = file_metadata.file_name
 
         # Create file as early as possible with no content
@@ -111,11 +100,6 @@ class FileProcessor:
             logger.info(f"Successfully processed {filename}: {len(all_passages)} passages")
 
             # update job status
-            if job:
-                job.status = JobStatus.completed
-                job.metadata["num_passages"] = len(all_passages)
-                await self.job_manager.update_job_by_id_async(job_id=job.id, job_update=JobUpdate(**job.model_dump()), actor=self.actor)
-
             await self.file_manager.update_file_status(
                 file_id=file_metadata.id, actor=self.actor, processing_status=FileProcessingStatus.COMPLETED
             )
@@ -124,24 +108,8 @@ class FileProcessor:
 
         except Exception as e:
             logger.error(f"File processing failed for {filename}: {str(e)}")
-
-            # update job status
-            if job:
-                job.status = JobStatus.failed
-                job.metadata["error"] = str(e)
-                await self.job_manager.update_job_by_id_async(job_id=job.id, job_update=JobUpdate(**job.model_dump()), actor=self.actor)
-
             await self.file_manager.update_file_status(
                 file_id=file_metadata.id, actor=self.actor, processing_status=FileProcessingStatus.ERROR, error_message=str(e)
             )
 
             return []
-
-    def _extract_upload_file_metadata(self, file: UploadFile, source_id: str) -> FileMetadata:
-        file_metadata = {
-            "file_name": file.filename,
-            "file_path": None,
-            "file_type": mimetypes.guess_type(file.filename)[0] or file.content_type or "unknown",
-            "file_size": file.size if file.size is not None else None,
-        }
-        return FileMetadata(**file_metadata, source_id=source_id)

letta/services/helpers/agent_manager_helper.py

@@ -170,6 +170,14 @@ def derive_system_message(agent_type: AgentType, enable_sleeptime: Optional[bool
             # v2 drops references to specific blocks, and instead relies on the block description injections
             system = gpt_system.get_system_text("sleeptime_v2")
 
+        # ReAct
+        elif agent_type == AgentType.react_agent:
+            system = gpt_system.get_system_text("react")
+
+        # Workflow
+        elif agent_type == AgentType.workflow_agent:
+            system = gpt_system.get_system_text("workflow")
+
         else:
             raise ValueError(f"Invalid agent type: {agent_type}")
 

letta/services/passage_manager.py

@@ -3,12 +3,12 @@ from datetime import datetime, timezone
 from functools import lru_cache
 from typing import List, Optional
 
-from async_lru import alru_cache
 from openai import AsyncOpenAI, OpenAI
 from sqlalchemy import select
 
 from letta.constants import MAX_EMBEDDING_DIM
 from letta.embeddings import embedding_model, parse_and_chunk_text
+from letta.helpers.decorators import async_redis_cache
 from letta.orm.errors import NoResultFound
 from letta.orm.passage import AgentPassage, SourcePassage
 from letta.otel.tracing import trace_method
@@ -30,9 +30,8 @@ def get_openai_embedding(text: str, model: str, endpoint: str) -> List[float]:
     return response.data[0].embedding
 
 
-# TODO: Add redis-backed caching for backend
-@alru_cache(maxsize=8192)
-async def get_openai_embedding_async(text: str, model: str, endpoint: str) -> List[float]:
+@async_redis_cache(key_func=lambda text, model, endpoint: f"{model}:{endpoint}:{text}")
+async def get_openai_embedding_async(text: str, model: str, endpoint: str) -> list[float]:
     from letta.settings import model_settings
 
     client = AsyncOpenAI(api_key=model_settings.openai_api_key, base_url=endpoint, max_retries=0)

letta/services/step_manager.py

@@ -34,6 +34,7 @@ class StepManager:
         model: Optional[str] = None,
         agent_id: Optional[str] = None,
         trace_ids: Optional[list[str]] = None,
+        feedback: Optional[Literal["positive", "negative"]] = None,
     ) -> List[PydanticStep]:
         """List all jobs with optional pagination and status filter."""
         async with db_registry.async_session() as session:
@@ -44,7 +45,8 @@ class StepManager:
                 filter_kwargs["agent_id"] = agent_id
             if trace_ids:
                 filter_kwargs["trace_id"] = trace_ids
-
+            if feedback:
+                filter_kwargs["feedback"] = feedback
             steps = await StepModel.list_async(
                 db_session=session,
                 before=before,
@@ -150,6 +152,19 @@ class StepManager:
             step = await StepModel.read_async(db_session=session, identifier=step_id, actor=actor)
             return step.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def add_feedback_async(
+        self, step_id: str, feedback: Optional[Literal["positive", "negative"]], actor: PydanticUser
+    ) -> PydanticStep:
+        async with db_registry.async_session() as session:
+            step = await StepModel.read_async(db_session=session, identifier=step_id, actor=actor)
+            if not step:
+                raise NoResultFound(f"Step with id {step_id} does not exist")
+            step.feedback = feedback
+            step = await step.update_async(session)
+            return step.to_pydantic()
+
     @enforce_types
     @trace_method
     def update_step_transaction_id(self, actor: PydanticUser, step_id: str, transaction_id: str) -> PydanticStep:

{letta_nightly-0.8.6.dev20250627104313.dist-info → letta_nightly-0.8.6.dev20250627191649.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.6.dev20250627104313
+Version: 0.8.6.dev20250627191649
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -29,7 +29,6 @@ Requires-Dist: aiosqlite (>=0.21.0,<0.22.0)
 Requires-Dist: alembic (>=1.13.3,<2.0.0)
 Requires-Dist: anthropic (>=0.49.0,<0.50.0)
 Requires-Dist: apscheduler (>=3.11.0,<4.0.0)
-Requires-Dist: async-lru (>=2.0.5,<3.0.0)
 Requires-Dist: asyncpg (>=0.30.0,<0.31.0) ; extra == "postgres"
 Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev" or extra == "all"
@@ -57,7 +56,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.169,<0.2.0)
+Requires-Dist: letta_client (>=0.1.173,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"

{letta_nightly-0.8.6.dev20250627104313.dist-info → letta_nightly-0.8.6.dev20250627191649.dist-info}/RECORD

@@ -7,7 +7,7 @@ letta/agents/ephemeral_summary_agent.py,sha256=MgJZxmlMU8ZKOKfqMAH7t2WMlf7zW0Zli
 letta/agents/exceptions.py,sha256=BQY4D4w32OYHM63CM19ko7dPwZiAzUs3NbKvzmCTcJg,318
 letta/agents/helpers.py,sha256=_lfaIzIc2xtUdnM0NmMvNwxljrlr3Y7VBHkmKyjwB_E,9810
 letta/agents/letta_agent.py,sha256=iOJvoxrlBjwYhjRSiQHBfpmc8MDoMyqwaCzRVk6kKfQ,53444
-letta/agents/letta_agent_batch.py,sha256=PgFHcZP7ttY5onTrTuh-8vaElSoFSMbm6RJrK4GLN2w,27842
+letta/agents/letta_agent_batch.py,sha256=cl9_nZYflIZWR23D_x_fUpmMHYITDWu0FUfPW1ivDuw,28031
 letta/agents/prompts/summary_system_prompt.txt,sha256=ftc-aEhfJYN6FlQF4I-I5me-BAh_T2nsTwitPZpZisE,2313
 letta/agents/voice_agent.py,sha256=FE9F1PN4nCUnNQhgoJssAFiJKZz1DiThyRDE3Xcf14Y,23420
 letta/agents/voice_sleeptime_agent.py,sha256=E9UVG6i3BqkHXUlOxn-0iSv07V_lwZ6TgODd8SGtFQM,8737
@@ -57,7 +57,7 @@ letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
 letta/helpers/composio_helpers.py,sha256=MwfmLt7tgjvxAXLHpx9pa5QolxcqoCbofb-30-DVpsI,1714
 letta/helpers/converters.py,sha256=_-6Ke5ZUtaKYmh8SncGj1ejTG3GyKhZ4ByVCrlcHsOI,15026
 letta/helpers/datetime_helpers.py,sha256=8AwZInX-NX_XQiqej2arozYqfC2ysnWpCJ9ETv8RdL0,4381
-letta/helpers/decorators.py,sha256=js85I5HbaRpAJ2BEeQEzLlw8xsFecHJWpnZlZXET_FU,5891
+letta/helpers/decorators.py,sha256=jyywXMxO5XPDSe93ybVXIOjTWkGX514S9BMcy_gP0j8,5891
 letta/helpers/json_helpers.py,sha256=PWZ5HhSqGXO4e563dM_8M72q7ScirjXQ4Rv1ckohaV8,396
 letta/helpers/message_helper.py,sha256=Xzf_VCMAXT0Ys8LVUh1ySVtgJwabSQYksOdPr7P4EJU,3549
 letta/helpers/singleton.py,sha256=Y4dG_ZBCcrogvl9iZ69bSLq-QltrdP8wHqKkhef8OBI,370
@@ -75,7 +75,7 @@ letta/interfaces/utils.py,sha256=c6jvO0dBYHh8DQnlN-B0qeNC64d3CSunhfqlFA4pJTY,278
 letta/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/jobs/helpers.py,sha256=kO4aj954xsQ1RAmkjY6LQQ7JEIGuhaxB1e9pzrYKHAY,914
 letta/jobs/llm_batch_job_polling.py,sha256=r_6D5RcqEJQgrdh-rnN7vdLD0GAQl-GGmIfCnV0naHQ,10299
-letta/jobs/scheduler.py,sha256=VpRyO2vuETNrarHOIWYctAkrD4WFtV57buUSHaLE89Y,10240
+letta/jobs/scheduler.py,sha256=P_M_x7NtF3foHGRVCaDMXSILiHur78r4lXYe4rq4Z-M,11491
 letta/jobs/types.py,sha256=K8GKEnqEgAT6Kq4F2hUrBC4ZAFM9OkfOjVMStzxKuXQ,742
 letta/llm_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/llm_api/anthropic.py,sha256=tbMy4483TySrEmbXD3juM6TpPRrV9_M3Fgp59sDBcqE,47935
@@ -173,7 +173,7 @@ letta/orm/source.py,sha256=rtehzez80rRrJigXeRBgTlfTZEUy6cVqDizWEN2tvuY,2224
 letta/orm/sources_agents.py,sha256=Ik_PokCBrXRd9wXWomeNeb8EtLUwjb9VMZ8LWXqpK5A,473
 letta/orm/sqlalchemy_base.py,sha256=W9JkvSCjWEMscAlfPKC1GHKM6PoVFTDHxjrGBq6MVgQ,44042
 letta/orm/sqlite_functions.py,sha256=JCScKiRlYCKxy9hChQ8wsk4GMKknZE24MunnG3fM1Gw,4255
-letta/orm/step.py,sha256=ZIMxDba_5Ca6aUH0GFr35qcVA86PMCzCIfCwd-HD3Do,3354
+letta/orm/step.py,sha256=SLsLY1g4nuUeI47q9rlXPBCSVUNX3lxYAYAIqxy-YK4,3517
 letta/orm/tool.py,sha256=oTDbvSNNW_jHjYbJqqsLLuXf9uFRTZTZh33TXAcZ898,2839
 letta/orm/tools_agents.py,sha256=r6t-V21w2_mG8n38zuUb5jOi_3hRxsjgezsLA4sg0m4,626
 letta/orm/user.py,sha256=rK5N5ViDxmesZMqVVHB7FcQNpcSoM-hB42MyI6q3MnI,1004
@@ -219,13 +219,15 @@ letta/prompts/system/memgpt_offline_memory.txt,sha256=rWEJeF-6aiinjkJM9hgLUYCmlE
 letta/prompts/system/memgpt_offline_memory_chat.txt,sha256=ituh7gDuio7nC2UKFB7GpBq6crxb8bYedQfJ0ADoPgg,3949
 letta/prompts/system/memgpt_sleeptime_chat.txt,sha256=ieHvVkJYE_4Z_vyUJS4KImBZCSQDcsUmy9IRF-FBpPE,4712
 letta/prompts/system/memgpt_v2_chat.txt,sha256=c8n3DfL-brPW0v2rIheeIHULCkEgOWeyLr4KRLCiwR8,4947
+letta/prompts/system/react.txt,sha256=AVPxs4dM_0bCvk68hPIQMgFGBnt-6Vor-i0YSjoMtCc,1547
 letta/prompts/system/sleeptime.txt,sha256=qoACziV1KoPk_nJMJHzEkyKQn9v9fmepWozAAixZc4s,3117
 letta/prompts/system/sleeptime_doc_ingest.txt,sha256=tyzHHzyDA2ib_XRwo5h5Ku9l_f-RSBPDJZrUusrQE80,2783
 letta/prompts/system/sleeptime_v2.txt,sha256=z-v0OVwKPSw_DF9ltTR2UlpW7hAhqz8ZC4M3yKDDnys,2425
 letta/prompts/system/voice_chat.txt,sha256=Q_vd2Q08z6qTIVeMML0z9706NG8aAq-scxvi--h5tG4,1853
 letta/prompts/system/voice_sleeptime.txt,sha256=LPh-XjAthvsdEkXoZ4NTzTUuMbMsMkoDl9ofCUJC7Us,3696
+letta/prompts/system/workflow.txt,sha256=pLOaUDsNFAzLs4xb9JgGtd1w-lrq0Q1E7SpFBttXYCI,834
 letta/pytest.ini,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/schemas/agent.py,sha256=BAPgvS4J8dh9GWxzoj5duW2jRlrJsRTUORn9sd1Ys1A,22521
+letta/schemas/agent.py,sha256=6BNV57XhMMDDQ8YZrFEurNw1L_srx0Cqen7xJyqfNKU,23908
 letta/schemas/block.py,sha256=awxCQKxmv4I4k9Au5h-a2RCeSVF54EfWyBQPtHRwuNQ,5585
 letta/schemas/embedding_config.py,sha256=By79UpBnjh6lg9q6c12th6EfzLSSUVgRbwofnhoI4hM,3762
 letta/schemas/embedding_config_overrides.py,sha256=lkTa4y-EQ2RnaEKtKDM0sEAk7EwNa67REw8DGNNtGQY,84
@@ -257,12 +259,12 @@ letta/schemas/organization.py,sha256=TXrHN4IBQnX-mWvRuCOH57XZSLYCVOY0wWm2_UzDQIA
 letta/schemas/passage.py,sha256=zO2azPqob_kM4XudOclcj29Ohnxd7qUbRqo75aTwWTo,3830
 letta/schemas/pip_requirement.py,sha256=OgcEPFjXyByTkhW30mQCM-CoU3C0V23opXmdcBV0rrw,488
 letta/schemas/provider_trace.py,sha256=gsgo1CdfTUFSnm1ep1tSZ0fZfGSx45EdPaVyVJREt_U,1958
-letta/schemas/providers.py,sha256=VrewNGjvC0ORcOPLbMr7wRT5zo1d9QlxZW9wnqcgyEQ,67740
+letta/schemas/providers.py,sha256=G6joCsrAti81Ua4YikvIT3Kw7QtuReSudc0I1tbWW7k,67742
 letta/schemas/response_format.py,sha256=pXNsjbtpA3Tf8HsDyIa40CSmoUbVR_7n2WOfQaX4aFs,2204
 letta/schemas/run.py,sha256=1lVOWlHVbk9MYIOiIrE1gCoQvBhErKo7UMSeWyMExbw,2089
 letta/schemas/sandbox_config.py,sha256=thI4p7R4nnW1W-F_PBNkpmyHXpSH_lorlQX8YxDXSe0,5252
 letta/schemas/source.py,sha256=ZDeTjkNp1rKamG7xZzoUHeCptjpW9WNLzAcJ9QQRxlM,3444
-letta/schemas/step.py,sha256=uw-n55jSc3O_NaqX7p4Xp73NxndAn1Kgs4nkHi9ALDw,2339
+letta/schemas/step.py,sha256=LJ6_NJ5q9ZyUzxHAnH4caoM2mH7L2YIOlcu5bUQLAyE,2516
 letta/schemas/tool.py,sha256=NFvF7kA2DvE9ecZSCnAGw8Ss4fEYvb9nWXMIMvS843Y,14195
 letta/schemas/tool_execution_result.py,sha256=4P77llsUsZBnRd0PtPiC4VzGjx7i_-fUNgXQfCpMS9U,896
 letta/schemas/tool_rule.py,sha256=dJ-qNDy0LneTt_DhKXsRyC9NAJxZ_aWY3IRpzGuH_sY,10910
@@ -283,7 +285,7 @@ letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/db.py,sha256=WYuTpqzJxi98WownUX5VZFPzsc99Pp91xPSNYiU5_KU,10631
 letta/server/generate_openapi_schema.sh,sha256=0OtBhkC1g6CobVmNEd_m2B6sTdppjbJLXaM95icejvE,371
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/server/rest_api/app.py,sha256=FNqifySn-uZJkZ6zKkNCKrXfaK2k_VtSS18Bf8N0ZGg,15919
+letta/server/rest_api/app.py,sha256=K7aunRgF3dBtnoE6duYaCHeXw5_Rz5FgtMAa4Y8pydc,17526
 letta/server/rest_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/auth/index.py,sha256=fQBGyVylGSRfEMLQ17cZzrHd5Y1xiVylvPqH5Rl-lXQ,1378
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
@@ -307,11 +309,11 @@ letta/server/rest_api/routers/v1/organizations.py,sha256=5NEjTOdGKWrfN584jfPpJhA
 letta/server/rest_api/routers/v1/providers.py,sha256=8SJ_RsSk7L4nh1f_uFE31JOxefmGhOfN-fMJ0Sp6SJo,4353
 letta/server/rest_api/routers/v1/runs.py,sha256=vieUp7uTvRTdAte0Nw1bqX2APMATZhKTr2R1HVNJT74,8879
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=pKuy88GD3atrBkKa7VVfKTjg8Y07e1vVtdw4TtxkQBk,8910
-letta/server/rest_api/routers/v1/sources.py,sha256=kCXkcR8pH34wtFPHvxxfPyiqwUO5cnZRo_9GLFpWlOw,16833
-letta/server/rest_api/routers/v1/steps.py,sha256=P6pnSRI1ZJesqQdPm9x1bw-j_0UaH_pAtcHXyko8_8Q,3477
+letta/server/rest_api/routers/v1/sources.py,sha256=-_jWL2jDqOt2r0IUUxjHjxf4TZhAJDdt7_J5f_kGF_U,17094
+letta/server/rest_api/routers/v1/steps.py,sha256=uNEQVEeRU9RwYuD2Dz1PzZy04nyvMSTY0Tx0WrMEgVs,4362
 letta/server/rest_api/routers/v1/tags.py,sha256=ef94QitUSJ3NQVffWF1ZqANUZ2b2jRyGHp_I3UUjhno,912
 letta/server/rest_api/routers/v1/telemetry.py,sha256=z53BW3Pefi3eWy47FPJyGhFWbZicX9jPJUi5LC5c3sk,790
-letta/server/rest_api/routers/v1/tools.py,sha256=0vBWGLT8bTGeIcIU3jdR6kgFZHKurGMA1uNW_Ei5qbc,25160
+letta/server/rest_api/routers/v1/tools.py,sha256=JYHy522vclWJXouzLpLQJGEXLgTtoWk4w6LQgiUdtMQ,27672
 letta/server/rest_api/routers/v1/users.py,sha256=a0J3Ad8kWHxi3vUJB5r9K2GmiplSABZXwhA83o8HbpI,2367
 letta/server/rest_api/routers/v1/voice.py,sha256=ghMBp5Uovbf0-3nN6d9P5kpl1hHACLRMhIDGQp96G9Q,1986
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
@@ -331,7 +333,7 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=5mDgpfNZn_kNwHnpt5Dsuw8gdNH298sgxTGed3etzYg,1836
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=IJpAVc9MV5y3uDd4zrSIibh8tfPHjC4-JZemk3G7rOg,119667
+letta/services/agent_manager.py,sha256=w636-jxEp1YglX3z9fSWotmlrvFJcHBBOV2gzNMB1c8,120893
 letta/services/block_manager.py,sha256=YwDGdy6f6MNXVXVOxIMOOP6IEWT8h-k5uQlveof0pyE,22744
 letta/services/context_window_calculator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/context_window_calculator/context_window_calculator.py,sha256=H0-Ello1DHV28MnzMseWrg--jarDc6YwCcgwPlWjtZk,6527
@@ -343,7 +345,7 @@ letta/services/file_processor/chunker/line_chunker.py,sha256=Lm5iZR7tFyOlew8XrZp
 letta/services/file_processor/chunker/llama_index_chunker.py,sha256=dEBf33TifD_BcxjNAULim9NDF8VPG8EQkjeR9saK4t4,3982
 letta/services/file_processor/embedder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/file_processor/embedder/openai_embedder.py,sha256=BjKsNqh_nfNIDVWkCR2noFX7E6Mr68FQtj79F2xeCpM,3545
-letta/services/file_processor/file_processor.py,sha256=D96Z-det6pq2CdB7c_lamJnDO1JEaZswUjNoQppc2mo,6064
+letta/services/file_processor/file_processor.py,sha256=xOcoQRgekcZo4JrrXMNYKSiuN4vPKxc81HuS2G3sFPs,4803
 letta/services/file_processor/file_types.py,sha256=AAwflpGrCmKBtZvzUR-TdOkOp5OGky6vm2ZbhRg7_WY,12982
 letta/services/file_processor/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/file_processor/parser/base_parser.py,sha256=WfnXP6fL-xQz4eIHEWa6-ZNEAARbF_alowqH4BAUzJo,238
@@ -351,7 +353,7 @@ letta/services/file_processor/parser/mistral_parser.py,sha256=Hzsrm36HbKQ7CWljTZ
 letta/services/file_processor/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/files_agents_manager.py,sha256=xBzXPrpbUF-HMMcK0js70QOgLv28AeJ21U0wC2Y9CBs,16592
 letta/services/group_manager.py,sha256=X2gKKUGKTXGRMC8YjwmE6EOB1cVM4lo31eCnmog7dPQ,23368
-letta/services/helpers/agent_manager_helper.py,sha256=HNVCRcGcYHknT0OPXByMpq8EfBPKCyyNIkCKBWwmD1I,42877
+letta/services/helpers/agent_manager_helper.py,sha256=2zPnxs1QFo_uGv1fG-pqwTQ-oFfgcqNjk9deLVNgby4,43134
 letta/services/helpers/tool_execution_helper.py,sha256=45L7woJ98jK5MQAnhE_4NZdCeyOOzC4328FTQPM7iTA,9159
 letta/services/helpers/tool_parser_helper.py,sha256=EI5tcre-D5U3mEzIMhfkAGlUwYckW1JlCJ-iqwoTTrc,4336
 letta/services/identity_manager.py,sha256=L8EYGYXA9sveLwPCTYZIdYZwOMnHex47TBiMYcco_y4,10575
@@ -366,12 +368,12 @@ letta/services/mcp/types.py,sha256=nmcnQn2EpxXzXg5_pWPsHZobfxO6OucaUgz1bVvam7o,1
 letta/services/mcp_manager.py,sha256=Ay3SRlBl8pHjZUVuaB0LgN4N-R4fGaIge9wSxCYKhZc,16488
 letta/services/message_manager.py,sha256=cNUTGJ2CuQkPhd1Ldfi4aj6wRVYdRKkGZzp767_7VE4,30080
 letta/services/organization_manager.py,sha256=PngZXPuzcCWB1CW7vAST9CsQZLysrpEdwHwhFN4_fhs,5838
-letta/services/passage_manager.py,sha256=4l1VYXPGmgzx-_3ApjJOHgDMbQO781nPoDfOj2dbN00,43310
+letta/services/passage_manager.py,sha256=nmrrWE3UFojw73Q1qrG5dvrLDotP4xD5ZQARaEO8nec,43349
 letta/services/per_agent_lock_manager.py,sha256=cMaW8r-qhucQbiK27jVqz8wzhlr2yuRNXbdkaMO4lnk,627
 letta/services/provider_manager.py,sha256=mEtiBF7kJgSzDwwyqSmWLT6kgvWPk-FERZ9Zw8QKpHw,9557
 letta/services/sandbox_config_manager.py,sha256=fcJkXCaA6vmrnTusHhns-c_aRXcPlFLICPGdWDaY8XQ,26138
 letta/services/source_manager.py,sha256=bfkfubjvlvnpkd-W6FcoQ0qDYxWkajut0ZY1cI56bbE,6197
-letta/services/step_manager.py,sha256=G6Vxkq_MePK5xCH_r7YXM42C9Sm65tl-nL0VWPr31gI,10723
+letta/services/step_manager.py,sha256=BqCz9guHYJqx9bu0wn2YCqcIHv80upT0eddyxiP0yvo,11452
 letta/services/summarizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/summarizer/enums.py,sha256=szzPX2OBRRJEZsBTGYQThrNz02ELFqhuLwvOR7ozi7A,208
 letta/services/summarizer/summarizer.py,sha256=9UHxZ1YPIIUWMK5_kz4_Kf5Qj9eHOo2zeEcmbzfUi_o,9275
@@ -403,8 +405,8 @@ letta/templates/sandbox_code_file_async.py.j2,sha256=hL6UWt4L16o79OPOBq1_Cw7gR5-
 letta/templates/template_helper.py,sha256=uHWO1PukgMoIIvgqQdPyHq3o3CQ6mcjUjTGvx9VLGkk,409
 letta/types/__init__.py,sha256=hokKjCVFGEfR7SLMrtZsRsBfsC7yTIbgKPLdGg4K1eY,147
 letta/utils.py,sha256=ZfyAcRBITlYs2XM5fHj_Lp08fPFMBMaQSPbfYlETbDs,33198
-letta_nightly-0.8.6.dev20250627104313.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.8.6.dev20250627104313.dist-info/METADATA,sha256=ojZG4LX3_9uk4YJV3QIuxUtzHPZfrb_ixTDC0WZoP5M,22883
-letta_nightly-0.8.6.dev20250627104313.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.8.6.dev20250627104313.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.8.6.dev20250627104313.dist-info/RECORD,,
+letta_nightly-0.8.6.dev20250627191649.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.8.6.dev20250627191649.dist-info/METADATA,sha256=W_RoYIS-EHFY3ZTIK6lyv0ExJfxAR6Rqie09TGdnyNc,22841
+letta_nightly-0.8.6.dev20250627191649.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.8.6.dev20250627191649.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.8.6.dev20250627191649.dist-info/RECORD,,