letta-nightly 0.8.6.dev20250627104313__tar.gz → 0.8.6.dev20250627191649__tar.gz

{letta_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/PKG-INFO

@@ -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 → letta_nightly-0.8.6.dev20250627191649}/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_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/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_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/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_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/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_nightly-0.8.6.dev20250627191649/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_nightly-0.8.6.dev20250627191649/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_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/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_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/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_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/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_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/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_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/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_nightly-0.8.6.dev20250627104313 → letta_nightly-0.8.6.dev20250627191649}/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,