letta-nightly 0.8.6.dev20250627214853__tar.gz → 0.8.7.dev20250627220731__tar.gz

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/PKG-INFO

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

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/__init__.py

@@ -1,6 +1,7 @@
 import os
 
-__version__ = "0.8.5"
+__version__ = "0.8.7"
+
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/constants.py

@@ -83,6 +83,7 @@ SEND_MESSAGE_TOOL_NAME = "send_message"
 # Base tools that cannot be edited, as they access agent state directly
 # Note that we don't include "conversation_search_date" for now
 BASE_TOOLS = [SEND_MESSAGE_TOOL_NAME, "conversation_search", "archival_memory_insert", "archival_memory_search"]
+DEPRECATED_BASE_TOOLS = ["archival_memory_insert", "archival_memory_search"]
 # Base memory tools CAN be edited, and are added by default by the server
 BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]
 # New v2 collection of the base memory tools (effecitvely same as sleeptime set), to pair with memgpt_v2 prompt
@@ -129,7 +130,7 @@ MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(
 BUILTIN_TOOLS = ["run_code", "web_search"]
 
 # Built in tools
-FILES_TOOLS = ["open_file", "close_file", "grep", "search_files"]
+FILES_TOOLS = ["open_files", "grep_files", "search_files"]
 
 FILE_MEMORY_EXISTS_MESSAGE = "The following files are currently accessible in memory:"
 FILE_MEMORY_EMPTY_MESSAGE = (

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/functions/function_sets/files.py

@@ -1,30 +1,32 @@
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, List, Optional
+
+from letta.functions.types import FileOpenRequest
 
 if TYPE_CHECKING:
     from letta.schemas.agent import AgentState
     from letta.schemas.file import FileMetadata
 
 
-async def open_file(agent_state: "AgentState", file_name: str, view_range: Optional[Tuple[int, int]]) -> str:
-    """
-    Open the file with name `file_name` and load the contents into files section in core memory.
+async def open_files(agent_state: "AgentState", file_requests: List[FileOpenRequest], close_all_others: bool = False) -> str:
+    """Open one or more files and load their contents into files section in core memory. Maximum of 5 files can be opened simultaneously.
 
-    Args:
-        file_name (str): Name of the file to view. Required.
-        view_range (Optional[Tuple[int, int]]): Optional tuple indicating range to view.
+    Examples:
+        Open single file (entire content):
+            file_requests = [FileOpenRequest(file_name="config.py")]
 
-    Returns:
-        str: A status message
-    """
-    raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
+        Open multiple files with different view ranges:
+            file_requests = [
+                FileOpenRequest(file_name="config.py", offset=1, length=50),     # Lines 1-50
+                FileOpenRequest(file_name="main.py", offset=100, length=100),    # Lines 100-199
+                FileOpenRequest(file_name="utils.py")                            # Entire file
+            ]
 
-
-async def close_file(agent_state: "AgentState", file_name: str) -> str:
-    """
-    Close file with name `file_name` in files section in core memory.
+        Close all other files and open new ones:
+            open_files(agent_state, file_requests, close_all_others=True)
 
     Args:
-        file_name (str): Name of the file to close.
+        file_requests (List[FileOpenRequest]): List of file open requests, each specifying file name and optional view range.
+        close_all_others (bool): If True, closes all other currently open files first. Defaults to False.
 
     Returns:
         str: A status message
@@ -32,7 +34,7 @@ async def close_file(agent_state: "AgentState", file_name: str) -> str:
     raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
 
 
-async def grep(
+async def grep_files(
     agent_state: "AgentState",
     pattern: str,
     include: Optional[str] = None,
@@ -45,7 +47,7 @@ async def grep(
         pattern (str): Keyword or regex pattern to search within file contents.
         include (Optional[str]): Optional keyword or regex pattern to filter filenames to include in the search.
         context_lines (Optional[int]): Number of lines of context to show before and after each match.
-                                       Equivalent to `-C` in grep. Defaults to 3.
+                                       Equivalent to `-C` in grep_files. Defaults to 3.
 
     Returns:
         str: Matching lines with optional surrounding context or a summary output.

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/functions/schema_generator.py

@@ -9,6 +9,56 @@ from typing_extensions import Literal
 
 from letta.constants import REQUEST_HEARTBEAT_DESCRIPTION, REQUEST_HEARTBEAT_PARAM
 from letta.functions.mcp_client.types import MCPTool
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
+
+def validate_google_style_docstring(function):
+    """Validate that a function's docstring follows Google Python style format.
+
+    Args:
+        function: The function to validate
+
+    Raises:
+        ValueError: If the docstring is not in Google Python style format
+    """
+    if not function.__doc__:
+        raise ValueError(
+            f"Function '{function.__name__}' has no docstring. Expected Google Python style docstring with Args and Returns sections."
+        )
+
+    docstring = function.__doc__.strip()
+
+    # Basic Google style requirements:
+    # 1. Should have Args: section if function has parameters (excluding self, agent_state)
+    # 2. Should have Returns: section if function returns something other than None
+    # 3. Args and Returns sections should be properly formatted
+
+    sig = inspect.signature(function)
+    has_params = any(param.name not in ["self", "agent_state"] for param in sig.parameters.values())
+
+    # Check for Args section if function has parameters
+    if has_params and "Args:" not in docstring:
+        raise ValueError(f"Function '{function.__name__}' with parameters must have 'Args:' section in Google Python style docstring")
+
+    # NOTE: No check for Returns section - this is irrelevant to the LLM
+    # In proper Google Python format, the Returns: is required
+
+    # Validate Args section format if present
+    if "Args:" in docstring:
+        args_start = docstring.find("Args:")
+        args_end = docstring.find("Returns:", args_start) if "Returns:" in docstring[args_start:] else len(docstring)
+        args_section = docstring[args_start:args_end].strip()
+
+        # Check that each parameter is documented
+        for param in sig.parameters.values():
+            if param.name in ["self", "agent_state"]:
+                continue
+            if f"{param.name} (" not in args_section and f"{param.name}:" not in args_section:
+                raise ValueError(
+                    f"Function '{function.__name__}' parameter '{param.name}' not documented in Args section of Google Python style docstring"
+                )
 
 
 def is_optional(annotation):
@@ -277,6 +327,20 @@ def pydantic_model_to_json_schema(model: Type[BaseModel]) -> dict:
                 "description": prop["description"],
             }
 
+        # Handle the case where the property uses anyOf (e.g., Optional types)
+        if "anyOf" in prop:
+            # For Optional types, extract the non-null type
+            non_null_types = [t for t in prop["anyOf"] if t.get("type") != "null"]
+            if len(non_null_types) == 1:
+                # Simple Optional[T] case - use the non-null type
+                return {
+                    "type": non_null_types[0]["type"],
+                    "description": prop["description"],
+                }
+            else:
+                # Complex anyOf case - not supported yet
+                raise ValueError(f"Complex anyOf patterns are not supported: {prop}")
+
         # If it's a regular property with a direct type (e.g., string, number)
         return {
             "type": "string" if prop["type"] == "string" else prop["type"],
@@ -344,7 +408,18 @@ def pydantic_model_to_json_schema(model: Type[BaseModel]) -> dict:
     return clean_schema(schema_part=schema, full_schema=schema)
 
 
-def generate_schema(function, name: Optional[str] = None, description: Optional[str] = None) -> dict:
+def generate_schema(function, name: Optional[str] = None, description: Optional[str] = None, tool_id: Optional[str] = None) -> dict:
+    # Validate that the function has a Google Python style docstring
+    try:
+        validate_google_style_docstring(function)
+    except ValueError:
+        logger.warning(
+            f"Function `{function.__name__}` in module `{function.__module__}` "
+            f"{'(tool_id=' + tool_id + ') ' if tool_id else ''}"
+            f"is not in Google style docstring format. "
+            f"Docstring received:\n{repr(function.__doc__[:200]) if function.__doc__ else 'None'}"
+        )
+
     # Get the signature of the function
     sig = inspect.signature(function)
 
@@ -353,10 +428,19 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
 
     if not description:
         # Support multiline docstrings for complex functions, TODO (cliandy): consider having this as a setting
-        if docstring.long_description:
+        # Always prefer combining short + long description when both exist
+        if docstring.short_description and docstring.long_description:
+            description = f"{docstring.short_description}\n\n{docstring.long_description}"
+        elif docstring.short_description:
+            description = docstring.short_description
+        elif docstring.long_description:
             description = docstring.long_description
         else:
-            description = docstring.short_description
+            description = "No description available"
+
+        examples_section = extract_examples_section(function.__doc__)
+        if examples_section and "Examples:" not in description:
+            description = f"{description}\n\n{examples_section}"
 
     # Prepare the schema dictionary
     schema = {
@@ -443,6 +527,38 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
     return schema
 
 
+def extract_examples_section(docstring: Optional[str]) -> Optional[str]:
+    """Extracts the 'Examples:' section from a Google-style docstring.
+
+    Args:
+        docstring (Optional[str]): The full docstring of a function.
+
+    Returns:
+        Optional[str]: The extracted examples section, or None if not found.
+    """
+    if not docstring or "Examples:" not in docstring:
+        return None
+
+    lines = docstring.strip().splitlines()
+    in_examples = False
+    examples_lines = []
+
+    for line in lines:
+        stripped = line.strip()
+
+        if not in_examples and stripped.startswith("Examples:"):
+            in_examples = True
+            examples_lines.append(line)
+            continue
+
+        if in_examples:
+            if stripped and not line.startswith(" ") and stripped.endswith(":"):
+                break
+            examples_lines.append(line)
+
+    return "\n".join(examples_lines).strip() if examples_lines else None
+
+
 def generate_schema_from_args_schema_v2(
     args_schema: Type[BaseModel], name: Optional[str] = None, description: Optional[str] = None, append_heartbeat: bool = True
 ) -> Dict[str, Any]:

letta_nightly-0.8.7.dev20250627220731/letta/functions/types.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class SearchTask(BaseModel):
+    query: str = Field(description="Search query for web search")
+    question: str = Field(description="Question to answer from search results, considering full conversation context")
+
+
+class FileOpenRequest(BaseModel):
+    file_name: str = Field(description="Name of the file to open")
+    offset: Optional[int] = Field(
+        default=None, description="Optional starting line number (1-indexed). If not specified, starts from beginning of file."
+    )
+    length: Optional[int] = Field(
+        default=None, description="Optional number of lines to view from offset. If not specified, views to end of file."
+    )

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/groups/sleeptime_multi_agent_v2.py

@@ -141,7 +141,11 @@ class SleeptimeMultiAgentV2(BaseAgent):
         include_return_message_types: Optional[List[MessageType]] = None,
     ):
         response = await self.step(
-            input_messages, max_steps, use_assistant_message, request_start_timestamp_ns, include_return_message_types
+            input_messages=input_messages,
+            max_steps=max_steps,
+            use_assistant_message=use_assistant_message,
+            request_start_timestamp_ns=request_start_timestamp_ns,
+            include_return_message_types=include_return_message_types,
         )
 
         for message in response.messages:

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/orm/sqlalchemy_base.py

@@ -183,6 +183,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         identifier_keys: Optional[List[str]] = None,
         identity_id: Optional[str] = None,
         query_options: Sequence[ORMOption] | None = None,  # ← new
+        has_feedback: Optional[bool] = None,
         **kwargs,
     ) -> List["SqlalchemyBase"]:
         """
@@ -281,6 +282,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         identifier_keys: Optional[List[str]] = None,
         identity_id: Optional[str] = None,
         check_is_deleted: bool = False,
+        has_feedback: Optional[bool] = None,
         **kwargs,
     ):
         """
@@ -337,6 +339,13 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         if end_date:
             query = query.filter(cls.created_at < end_date)
 
+        # Feedback filtering
+        if has_feedback is not None and hasattr(cls, "feedback"):
+            if has_feedback:
+                query = query.filter(cls.feedback.isnot(None))
+            else:
+                query = query.filter(cls.feedback.is_(None))
+
         # Handle pagination based on before/after
         if before_obj or after_obj:
             conditions = []

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/schemas/agent.py

@@ -152,9 +152,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     initial_message_sequence: Optional[List[MessageCreate]] = Field(
         None, description="The initial set of messages to put in the agent's in-context memory."
     )
-    include_base_tools: bool = Field(
-        True, description="If true, attaches the Letta core tools (e.g. archival_memory and core_memory related functions)."
-    )
+    include_base_tools: bool = Field(True, description="If true, attaches the Letta core tools (e.g. core_memory related functions).")
     include_multi_agent_tools: bool = Field(
         False, description="If true, attaches the Letta multi-agent tools (e.g. sending a message to another agent)."
     )

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/server/rest_api/routers/v1/steps.py

@@ -7,6 +7,7 @@ from letta.orm.errors import NoResultFound
 from letta.schemas.step import Step
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
+from letta.services.step_manager import FeedbackType
 
 router = APIRouter(prefix="/steps", tags=["steps"])
 
@@ -23,6 +24,7 @@ async def list_steps(
     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"),
+    has_feedback: Optional[bool] = Query(None, description="Filter by whether steps have feedback (true) or not (false)"),
     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"),
@@ -49,6 +51,7 @@ async def list_steps(
         agent_id=agent_id,
         trace_ids=trace_ids,
         feedback=feedback,
+        has_feedback=has_feedback,
         tags=tags,
     )
 
@@ -72,7 +75,7 @@ async def retrieve_step(
 @router.patch("/{step_id}/feedback", response_model=Step, operation_id="add_feedback")
 async def add_feedback(
     step_id: str,
-    feedback: Optional[Literal["positive", "negative"]],
+    feedback: Optional[FeedbackType],
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: SyncServer = Depends(get_letta_server),
 ):

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/server/server.py

@@ -1496,7 +1496,7 @@ class SyncServer(Server):
             await self.agent_manager.attach_block_async(agent_id=main_agent.id, block_id=block.id, actor=actor)
 
         if clear_history and block.value != "":
-            block = await self.block_manager.update_block_async(block_id=block.id, block=BlockUpdate(value=""))
+            block = await self.block_manager.update_block_async(block_id=block.id, block_update=BlockUpdate(value=""), actor=actor)
 
         request = CreateAgent(
             name=main_agent.name + "-doc-sleeptime",

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/services/agent_manager.py

@@ -16,6 +16,7 @@ from letta.constants import (
     BASE_VOICE_SLEEPTIME_CHAT_TOOLS,
     BASE_VOICE_SLEEPTIME_TOOLS,
     DEFAULT_TIMEZONE,
+    DEPRECATED_BASE_TOOLS,
     FILES_TOOLS,
     MULTI_AGENT_TOOLS,
 )
@@ -77,6 +78,7 @@ from letta.services.helpers.agent_manager_helper import (
     build_agent_passage_query,
     build_passage_query,
     build_source_passage_query,
+    calculate_base_tools,
     check_supports_structured_output,
     compile_system_message,
     derive_system_message,
@@ -261,13 +263,13 @@ class AgentManager:
             elif agent_create.enable_sleeptime:
                 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)
+                tool_names |= calculate_base_tools(is_v2=True)
             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)
+                tool_names |= calculate_base_tools(is_v2=False)
         if agent_create.include_multi_agent_tools:
             tool_names |= set(MULTI_AGENT_TOOLS)
 
@@ -428,16 +430,19 @@ class AgentManager:
             elif agent_create.enable_sleeptime:
                 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)
+                tool_names |= calculate_base_tools(is_v2=True)
             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)
+                tool_names |= calculate_base_tools(is_v2=False)
         if agent_create.include_multi_agent_tools:
             tool_names |= set(MULTI_AGENT_TOOLS)
 
+        # take out the deprecated tool names
+        tool_names.difference_update(set(DEPRECATED_BASE_TOOLS))
+
         supplied_ids = set(agent_create.tool_ids or [])
 
         source_ids = agent_create.source_ids or []

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/services/file_processor/chunker/line_chunker.py

@@ -124,8 +124,8 @@ class LineChunker:
         else:
             line_offset = 0
 
-        # Add line numbers for all strategies
-        content_lines = [f"{i + line_offset}: {line}" for i, line in enumerate(content_lines)]
+        # Add line numbers for all strategies (1-indexed for user display)
+        content_lines = [f"{i + line_offset + 1}: {line}" for i, line in enumerate(content_lines)]
 
         # Add metadata about total chunks
         if add_metadata:
@@ -133,7 +133,10 @@ class LineChunker:
                 "sentences" if strategy == ChunkingStrategy.DOCUMENTATION else "chunks" if strategy == ChunkingStrategy.PROSE else "lines"
             )
             if start is not None and end is not None:
-                content_lines.insert(0, f"[Viewing {chunk_type} {start} to {end-1} (out of {total_chunks} {chunk_type})]")
+                # Display 1-indexed ranges for users
+                start_display = start + 1
+                end_display = end
+                content_lines.insert(0, f"[Viewing {chunk_type} {start_display} to {end_display} (out of {total_chunks} {chunk_type})]")
             else:
                 content_lines.insert(0, f"[Viewing file start (out of {total_chunks} {chunk_type})]")
 

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/services/files_agents_manager.py

@@ -283,6 +283,40 @@ class FileAgentManager:
             await session.execute(stmt)
             await session.commit()
 
+    @enforce_types
+    @trace_method
+    async def close_all_other_files(self, *, agent_id: str, keep_file_names: List[str], actor: PydanticUser) -> List[str]:
+        """Close every open file for this agent except those in keep_file_names.
+
+        Args:
+            agent_id: ID of the agent
+            keep_file_names: List of file names to keep open
+            actor: User performing the action
+
+        Returns:
+            List of file names that were closed
+        """
+        async with db_registry.async_session() as session:
+            stmt = (
+                update(FileAgentModel)
+                .where(
+                    and_(
+                        FileAgentModel.agent_id == agent_id,
+                        FileAgentModel.organization_id == actor.organization_id,
+                        FileAgentModel.is_open.is_(True),
+                        # Only add the NOT IN filter when there are names to keep
+                        ~FileAgentModel.file_name.in_(keep_file_names) if keep_file_names else True,
+                    )
+                )
+                .values(is_open=False, visible_content=None)
+                .returning(FileAgentModel.file_name)  # Gets the names we closed
+                .execution_options(synchronize_session=False)  # No need to sync ORM state
+            )
+
+            closed_file_names = [row.file_name for row in (await session.execute(stmt))]
+            await session.commit()
+            return closed_file_names
+
     @enforce_types
     @trace_method
     async def enforce_max_open_files_and_open(

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/services/helpers/agent_manager_helper.py

@@ -1,12 +1,20 @@
 from datetime import datetime
-from typing import List, Literal, Optional
+from typing import List, Literal, Optional, Set
 
 import numpy as np
 from sqlalchemy import Select, and_, asc, desc, func, literal, nulls_last, or_, select, union_all
 from sqlalchemy.sql.expression import exists
 
 from letta import system
-from letta.constants import IN_CONTEXT_MEMORY_KEYWORD, MAX_EMBEDDING_DIM, STRUCTURED_OUTPUT_MODELS
+from letta.constants import (
+    BASE_MEMORY_TOOLS,
+    BASE_MEMORY_TOOLS_V2,
+    BASE_TOOLS,
+    DEPRECATED_BASE_TOOLS,
+    IN_CONTEXT_MEMORY_KEYWORD,
+    MAX_EMBEDDING_DIM,
+    STRUCTURED_OUTPUT_MODELS,
+)
 from letta.embeddings import embedding_model
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import format_datetime, get_local_time, get_local_time_fast
@@ -1038,3 +1046,10 @@ def build_agent_passage_query(
             query = query.order_by(AgentPassage.created_at.desc(), AgentPassage.id.asc())
 
     return query
+
+
+def calculate_base_tools(is_v2: bool) -> Set[str]:
+    if is_v2:
+        return (set(BASE_TOOLS) - set(DEPRECATED_BASE_TOOLS)) | set(BASE_MEMORY_TOOLS_V2)
+    else:
+        return (set(BASE_TOOLS) - set(DEPRECATED_BASE_TOOLS)) | set(BASE_MEMORY_TOOLS)

{letta_nightly-0.8.6.dev20250627214853 → letta_nightly-0.8.7.dev20250627220731}/letta/services/step_manager.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from enum import Enum
 from typing import List, Literal, Optional
 
 from sqlalchemy import select
@@ -18,6 +19,11 @@ from letta.server.db import db_registry
 from letta.utils import enforce_types
 
 
+class FeedbackType(str, Enum):
+    POSITIVE = "positive"
+    NEGATIVE = "negative"
+
+
 class StepManager:
 
     @enforce_types
@@ -35,6 +41,7 @@ class StepManager:
         agent_id: Optional[str] = None,
         trace_ids: Optional[list[str]] = None,
         feedback: Optional[Literal["positive", "negative"]] = None,
+        has_feedback: Optional[bool] = None,
     ) -> List[PydanticStep]:
         """List all jobs with optional pagination and status filter."""
         async with db_registry.async_session() as session:
@@ -55,6 +62,7 @@ class StepManager:
                 end_date=end_date,
                 limit=limit,
                 ascending=True if order == "asc" else False,
+                has_feedback=has_feedback,
                 **filter_kwargs,
             )
             return [step.to_pydantic() for step in steps]
@@ -154,9 +162,7 @@ class StepManager:
 
     @enforce_types
     @trace_method
-    async def add_feedback_async(
-        self, step_id: str, feedback: Optional[Literal["positive", "negative"]], actor: PydanticUser
-    ) -> PydanticStep:
+    async def add_feedback_async(self, step_id: str, feedback: Optional[FeedbackType], 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:
@@ -250,6 +256,7 @@ class StepManager:
         return job
 
 
+# noinspection PyTypeChecker
 @singleton
 class NoopStepManager(StepManager):
     """
@@ -292,29 +299,4 @@ class NoopStepManager(StepManager):
         job_id: Optional[str] = None,
         step_id: Optional[str] = None,
     ) -> PydanticStep:
-        step_data = {
-            "origin": None,
-            "organization_id": actor.organization_id,
-            "agent_id": agent_id,
-            "provider_id": provider_id,
-            "provider_name": provider_name,
-            "provider_category": provider_category,
-            "model": model,
-            "model_endpoint": model_endpoint,
-            "context_window_limit": context_window_limit,
-            "completion_tokens": usage.completion_tokens,
-            "prompt_tokens": usage.prompt_tokens,
-            "total_tokens": usage.total_tokens,
-            "job_id": job_id,
-            "tags": [],
-            "tid": None,
-            "trace_id": get_trace_id(),  # Get the current trace ID
-        }
-        if step_id:
-            step_data["id"] = step_id
-        async with db_registry.async_session() as session:
-            if job_id:
-                await self._verify_job_access_async(session, job_id, actor, access=["write"])
-            new_step = StepModel(**step_data)
-            await new_step.create_async(session)
-            return new_step.to_pydantic()
+        return