letta-nightly 0.8.0.dev20250606195656__py3-none-any.whl → 0.8.2.dev20250606215616__py3-none-any.whl

letta/__init__.py

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

letta/agent.py

@@ -41,6 +41,7 @@ from letta.log import get_logger
 from letta.memory import summarize_messages
 from letta.orm import User
 from letta.orm.enums import ToolType
+from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent, get_prompt_template_for_agent_type
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -72,7 +73,6 @@ from letta.services.tool_manager import ToolManager
 from letta.settings import settings, summarizer_settings, model_settings
 from letta.streaming_interface import StreamingRefreshCLIInterface
 from letta.system import get_heartbeat, get_token_limit_warning, package_function_response, package_summarize_message, package_user_message
-from letta.tracing import log_event, trace_method
 from letta.utils import count_tokens, get_friendly_error_msg, get_tool_call_id, log_telemetry, parse_json, validate_function_response
 
 logger = get_logger(__name__)

letta/agents/letta_agent.py

@@ -14,9 +14,9 @@ from letta.agents.helpers import (
     _prepare_in_context_messages_no_persist_async,
     generate_step_id,
 )
-from letta.errors import LLMContextWindowExceededError
+from letta.errors import ContextWindowExceededError
 from letta.helpers import ToolRulesSolver
-from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.helpers.datetime_helpers import AsyncTimer, get_utc_timestamp_ns, ns_to_ms
 from letta.helpers.tool_execution_helper import enable_strict_mode
 from letta.interfaces.anthropic_streaming_interface import AnthropicStreamingInterface
 from letta.interfaces.openai_streaming_interface import OpenAIStreamingInterface
@@ -25,6 +25,9 @@ from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
 from letta.orm.enums import ToolType
+from letta.otel.context import get_ctx_attributes
+from letta.otel.metric_registry import MetricRegistry
+from letta.otel.tracing import log_event, trace_method, tracer
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole, MessageStreamStatus
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
@@ -48,7 +51,7 @@ from letta.services.telemetry_manager import NoopTelemetryManager, TelemetryMana
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
 from letta.settings import model_settings
 from letta.system import package_function_response
-from letta.tracing import log_event, trace_method, tracer
+from letta.types import JsonDict
 from letta.utils import log_telemetry, validate_function_response
 
 logger = get_logger(__name__)
@@ -178,7 +181,7 @@ class LettaAgent(BaseAgent):
             # log llm request time
             now = get_utc_timestamp_ns()
             llm_request_ns = now - step_start
-            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ns // 1_000_000})
+            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": ns_to_ms(llm_request_ns)})
 
             response = llm_client.convert_response_to_chat_completion(response_data, in_context_messages, agent_state.llm_config)
 
@@ -210,7 +213,7 @@ class LettaAgent(BaseAgent):
             # log LLM request time
             now = get_utc_timestamp_ns()
             llm_request_ns = now - step_start
-            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ns // 1_000_000})
+            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": ns_to_ms(llm_request_ns)})
 
             persisted_messages, should_continue = await self._handle_ai_response(
                 tool_call,
@@ -227,7 +230,7 @@ class LettaAgent(BaseAgent):
             # log step time
             now = get_utc_timestamp_ns()
             step_ns = now - step_start
-            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": step_ns // 1_000_000})
+            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": ns_to_ms(step_ns)})
             agent_step_span.end()
 
             # Log LLM Trace
@@ -267,7 +270,7 @@ class LettaAgent(BaseAgent):
         if request_start_timestamp_ns:
             now = get_utc_timestamp_ns()
             request_ns = now - request_start_timestamp_ns
-            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": request_ns // 1_000_000})
+            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": ns_to_ms(request_ns)})
         request_span.end()
 
         # Return back usage
@@ -321,7 +324,7 @@ class LettaAgent(BaseAgent):
             # log LLM request time
             now = get_utc_timestamp_ns()
             llm_request_ns = now - step_start
-            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ns // 1_000_000})
+            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": ns_to_ms(llm_request_ns)})
 
             # TODO: add run_id
             usage.step_count += 1
@@ -363,7 +366,7 @@ class LettaAgent(BaseAgent):
             # log step time
             now = get_utc_timestamp_ns()
             step_ns = now - step_start
-            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": step_ns // 1_000_000})
+            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": ns_to_ms(step_ns)})
             agent_step_span.end()
 
             # Log LLM Trace
@@ -384,7 +387,7 @@ class LettaAgent(BaseAgent):
         if request_start_timestamp_ns:
             now = get_utc_timestamp_ns()
             request_ns = now - request_start_timestamp_ns
-            request_span.add_event(name="request_ms", attributes={"duration_ms": request_ns // 1_000_000})
+            request_span.add_event(name="request_ms", attributes={"duration_ms": ns_to_ms(request_ns)})
         request_span.end()
 
         # Extend the in context message ids
@@ -480,7 +483,7 @@ class LettaAgent(BaseAgent):
                 if first_chunk and request_span is not None:
                     now = get_utc_timestamp_ns()
                     ttft_ns = now - request_start_timestamp_ns
-                    request_span.add_event(name="time_to_first_token_ms", attributes={"ttft_ms": ttft_ns // 1_000_000})
+                    request_span.add_event(name="time_to_first_token_ms", attributes={"ttft_ms": ns_to_ms(ttft_ns)})
                     first_chunk = False
 
                 yield f"data: {chunk.model_dump_json()}\n\n"
@@ -490,6 +493,9 @@ class LettaAgent(BaseAgent):
             usage.completion_tokens += interface.output_tokens
             usage.prompt_tokens += interface.input_tokens
             usage.total_tokens += interface.input_tokens + interface.output_tokens
+            MetricRegistry().message_output_tokens.record(
+                interface.output_tokens, dict(get_ctx_attributes(), **{"model.name": agent_state.llm_config.model})
+            )
 
             # Persist input messages if not already
             # Special strategy to lower TTFT
@@ -500,7 +506,7 @@ class LettaAgent(BaseAgent):
             # log LLM request time
             now = get_utc_timestamp_ns()
             llm_request_ns = now - step_start
-            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ns // 1_000_000})
+            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": ns_to_ms(llm_request_ns)})
 
             # Process resulting stream content
             tool_call = interface.get_tool_call_object()
@@ -515,8 +521,7 @@ class LettaAgent(BaseAgent):
                     total_tokens=interface.input_tokens + interface.output_tokens,
                 ),
                 reasoning_content=reasoning_content,
-                pre_computed_assistant_message_id=interface.letta_assistant_message_id,
-                pre_computed_tool_message_id=interface.letta_tool_message_id,
+                pre_computed_assistant_message_id=interface.letta_message_id,
                 step_id=step_id,
                 agent_step_span=agent_step_span,
             )
@@ -526,7 +531,7 @@ class LettaAgent(BaseAgent):
             # log total step time
             now = get_utc_timestamp_ns()
             step_ns = now - step_start
-            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": step_ns // 1_000_000})
+            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": ns_to_ms(step_ns)})
             agent_step_span.end()
 
             # TODO (cliandy): the stream POST request span has ended at this point, we should tie this to the stream
@@ -556,8 +561,8 @@ class LettaAgent(BaseAgent):
                 ),
             )
 
-            if not use_assistant_message or should_continue:
-                tool_return = [msg for msg in persisted_messages if msg.role == "tool"][-1].to_letta_messages()[0]
+            tool_return = [msg for msg in persisted_messages if msg.role == "tool"][-1].to_letta_messages()[0]
+            if not (use_assistant_message and tool_return.name == "send_message"):
                 yield f"data: {tool_return.model_dump_json()}\n\n"
 
             if not should_continue:
@@ -577,7 +582,7 @@ class LettaAgent(BaseAgent):
         if request_start_timestamp_ns:
             now = get_utc_timestamp_ns()
             request_ns = now - request_start_timestamp_ns
-            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": request_ns // 1_000_000})
+            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": ns_to_ms(request_ns)})
         request_span.end()
 
         # TODO: Also yield out a letta usage stats SSE
@@ -604,10 +609,16 @@ class LettaAgent(BaseAgent):
                 )
                 log_event("agent.stream_no_tokens.llm_request.created")
 
+                async with AsyncTimer() as timer:
+                    response = await llm_client.request_async(request_data, agent_state.llm_config)
+                MetricRegistry().llm_execution_time_ms_histogram.record(
+                    timer.elapsed_ms,
+                    dict(get_ctx_attributes(), **{"model.name": agent_state.llm_config.model}),
+                )
                 # Attempt LLM request
                 return (
                     request_data,
-                    await llm_client.request_async(request_data, agent_state.llm_config),
+                    response,
                     current_in_context_messages,
                     new_in_context_messages,
                 )
@@ -654,9 +665,7 @@ class LettaAgent(BaseAgent):
                 if first_chunk and ttft_span is not None:
                     provider_request_start_timestamp_ns = get_utc_timestamp_ns()
                     provider_req_start_ns = provider_request_start_timestamp_ns - request_start_timestamp_ns
-                    ttft_span.add_event(
-                        name="provider_req_start_ns", attributes={"provider_req_start_ms": provider_req_start_ns // 1_000_000}
-                    )
+                    ttft_span.add_event(name="provider_req_start_ns", attributes={"provider_req_start_ms": ns_to_ms(provider_req_start_ns)})
 
                 # Attempt LLM request
                 return (
@@ -692,7 +701,7 @@ class LettaAgent(BaseAgent):
         llm_config: LLMConfig,
         force: bool,
     ) -> List[Message]:
-        if isinstance(e, LLMContextWindowExceededError):
+        if isinstance(e, ContextWindowExceededError):
             return await self._rebuild_context_window(
                 in_context_messages=in_context_messages, new_letta_messages=new_letta_messages, llm_config=llm_config, force=force
             )
@@ -775,6 +784,7 @@ class LettaAgent(BaseAgent):
                 ToolType.LETTA_SLEEPTIME_CORE,
                 ToolType.LETTA_VOICE_SLEEPTIME_CORE,
                 ToolType.LETTA_BUILTIN,
+                ToolType.LETTA_FILES_CORE,
                 ToolType.EXTERNAL_COMPOSIO,
                 ToolType.EXTERNAL_MCP,
             }
@@ -810,7 +820,6 @@ class LettaAgent(BaseAgent):
         usage: UsageStatistics,
         reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
         pre_computed_assistant_message_id: Optional[str] = None,
-        pre_computed_tool_message_id: Optional[str] = None,
         step_id: str | None = None,
         new_in_context_messages: Optional[List[Message]] = None,
         agent_step_span: Optional["Span"] = None,
@@ -822,6 +831,9 @@ class LettaAgent(BaseAgent):
         """
         tool_call_name = tool_call.function.name
         tool_call_args_str = tool_call.function.arguments
+        # Temp hack to gracefully handle parallel tool calling attempt, only take first one
+        if "}{" in tool_call_args_str:
+            tool_call_args_str = tool_call_args_str.split("}{", 1)[0] + "}"
 
         try:
             tool_args = json.loads(tool_call_args_str)
@@ -859,6 +871,7 @@ class LettaAgent(BaseAgent):
             tool_args=tool_args,
             agent_state=agent_state,
             agent_step_span=agent_step_span,
+            step_id=step_id,
         )
         log_telemetry(
             self.logger, "_handle_ai_response execute tool finish", tool_execution_result=tool_execution_result, tool_call_id=tool_call_id
@@ -926,7 +939,6 @@ class LettaAgent(BaseAgent):
             add_heartbeat_request_system_message=continue_stepping,
             reasoning_content=reasoning_content,
             pre_computed_assistant_message_id=pre_computed_assistant_message_id,
-            pre_computed_tool_message_id=pre_computed_tool_message_id,
             step_id=logged_step.id if logged_step else None,  # TODO (cliandy): eventually move over other agent loops
         )
 
@@ -937,10 +949,15 @@ class LettaAgent(BaseAgent):
 
     @trace_method
     async def _execute_tool(
-        self, tool_name: str, tool_args: dict, agent_state: AgentState, agent_step_span: Optional["Span"] = None
+        self,
+        tool_name: str,
+        tool_args: JsonDict,
+        agent_state: AgentState,
+        agent_step_span: Optional["Span"] = None,
+        step_id: str | None = None,
     ) -> "ToolExecutionResult":
         """
-        Executes a tool and returns (result, success_flag).
+        Executes a tool and returns the ToolExecutionResult.
         """
         from letta.schemas.tool_execution_result import ToolExecutionResult
 
@@ -972,7 +989,10 @@ class LettaAgent(BaseAgent):
         # TODO: Integrate sandbox result
         log_event(name=f"start_{tool_name}_execution", attributes=tool_args)
         tool_execution_result = await tool_execution_manager.execute_tool_async(
-            function_name=tool_name, function_args=tool_args, tool=target_tool
+            function_name=tool_name,
+            function_args=tool_args,
+            tool=target_tool,
+            step_id=step_id,
         )
         if agent_step_span:
             end_time = get_utc_timestamp_ns()
@@ -980,7 +1000,7 @@ class LettaAgent(BaseAgent):
                 name="tool_execution_completed",
                 attributes={
                     "tool_name": target_tool.name,
-                    "duration_ms": (end_time - start_time) // 1_000_000,
+                    "duration_ms": ns_to_ms((end_time - start_time)),
                     "success": tool_execution_result.success_flag,
                     "tool_type": target_tool.tool_type,
                     "tool_id": target_tool.id,

letta/agents/letta_agent_batch.py

@@ -16,6 +16,7 @@ from letta.llm_api.llm_client import LLMClient
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
 from letta.orm.enums import ToolType
+from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState, AgentStepState
 from letta.schemas.enums import AgentStepStatus, JobStatus, MessageStreamStatus, ProviderType
 from letta.schemas.job import JobUpdate
@@ -39,7 +40,6 @@ from letta.services.passage_manager import PassageManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
 from letta.settings import tool_settings
-from letta.tracing import log_event, trace_method
 
 logger = get_logger(__name__)
 
@@ -551,7 +551,6 @@ class LettaAgentBatch(BaseAgent):
             add_heartbeat_request_system_message=False,
             reasoning_content=reasoning_content,
             pre_computed_assistant_message_id=None,
-            pre_computed_tool_message_id=None,
             llm_batch_item_id=llm_batch_item_id,
         )
 

letta/agents/voice_agent.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import uuid
 from datetime import datetime, timedelta, timezone
@@ -81,8 +82,8 @@ class VoiceAgent(BaseAgent):
         self.summary_block_label = "human"
 
         # Cached archival memory/message size
-        self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_id)
-        self.num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_id)
+        self.num_messages = None
+        self.num_archival_memories = None
 
     def init_summarizer(self, agent_state: AgentState) -> Summarizer:
         if not agent_state.multi_agent_group:
@@ -118,13 +119,12 @@ class VoiceAgent(BaseAgent):
         Main streaming loop that yields partial tokens.
         Whenever we detect a tool call, we yield from _handle_ai_response as well.
         """
-        print("CALL STREAM")
         if len(input_messages) != 1 or input_messages[0].role != MessageRole.user:
             raise ValueError(f"Voice Agent was invoked with multiple input messages or message did not have role `user`: {input_messages}")
 
         user_query = input_messages[0].content[0].text
 
-        agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
+        agent_state = await self.agent_manager.get_agent_by_id_async(self.agent_id, actor=self.actor)
 
         # TODO: Refactor this so it uses our in-house clients
         # TODO: For now, piggyback off of OpenAI client for ease
@@ -140,7 +140,7 @@ class VoiceAgent(BaseAgent):
 
         summarizer = self.init_summarizer(agent_state=agent_state)
 
-        in_context_messages = self.message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=self.actor)
+        in_context_messages = await self.message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=self.actor)
         memory_edit_timestamp = get_utc_time()
         in_context_messages[0].content[0].text = compile_system_message(
             system_prompt=agent_state.system,
@@ -183,10 +183,6 @@ class VoiceAgent(BaseAgent):
         # Rebuild context window if desired
         await self._rebuild_context_window(summarizer, in_context_messages, letta_message_db_queue)
 
-        # TODO: This may be out of sync, if in between steps users add files
-        self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
-        self.num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
-
         yield "data: [DONE]\n\n"
 
     async def _handle_ai_response(
@@ -286,14 +282,14 @@ class VoiceAgent(BaseAgent):
     async def _rebuild_context_window(
         self, summarizer: Summarizer, in_context_messages: List[Message], letta_message_db_queue: List[Message]
     ) -> None:
-        new_letta_messages = self.message_manager.create_many_messages(letta_message_db_queue, actor=self.actor)
+        new_letta_messages = await self.message_manager.create_many_messages_async(letta_message_db_queue, actor=self.actor)
 
         # TODO: Make this more general and configurable, less brittle
         new_in_context_messages, updated = summarizer.summarize(
             in_context_messages=in_context_messages, new_letta_messages=new_letta_messages
         )
 
-        self.agent_manager.set_in_context_messages(
+        await self.agent_manager.set_in_context_messages_async(
             agent_id=self.agent_id, message_ids=[m.id for m in new_in_context_messages], actor=self.actor
         )
 
@@ -301,9 +297,19 @@ class VoiceAgent(BaseAgent):
         self,
         in_context_messages: List[Message],
         agent_state: AgentState,
-        num_messages: int | None = None,
-        num_archival_memories: int | None = None,
     ) -> List[Message]:
+        self.num_messages, self.num_archival_memories = await asyncio.gather(
+            (
+                self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+                if self.num_messages is None
+                else asyncio.sleep(0, result=self.num_messages)
+            ),
+            (
+                self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+                if self.num_archival_memories is None
+                else asyncio.sleep(0, result=self.num_archival_memories)
+            ),
+        )
         return await super()._rebuild_memory_async(
             in_context_messages, agent_state, num_messages=self.num_messages, num_archival_memories=self.num_archival_memories
         )

letta/agents/voice_sleeptime_agent.py

@@ -3,6 +3,7 @@ from typing import AsyncGenerator, List, Optional, Tuple, Union
 from letta.agents.helpers import _create_letta_response, serialize_message_history
 from letta.agents.letta_agent import LettaAgent
 from letta.orm.enums import ToolType
+from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.block import BlockUpdate
 from letta.schemas.enums import MessageStreamStatus
@@ -17,7 +18,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.services.summarizer.summarizer import Summarizer
-from letta.tracing import trace_method
+from letta.types import JsonDict
 
 
 class VoiceSleeptimeAgent(LettaAgent):
@@ -89,9 +90,16 @@ class VoiceSleeptimeAgent(LettaAgent):
         )
 
     @trace_method
-    async def _execute_tool(self, tool_name: str, tool_args: dict, agent_state: AgentState, agent_step_span: Optional["Span"] = None):
+    async def _execute_tool(
+        self,
+        tool_name: str,
+        tool_args: JsonDict,
+        agent_state: AgentState,
+        agent_step_span: Optional["Span"] = None,
+        step_id: str | None = None,
+    ) -> "ToolExecutionResult":
         """
-        Executes a tool and returns (result, success_flag).
+        Executes a tool and returns the ToolExecutionResult
         """
         from letta.schemas.tool_execution_result import ToolExecutionResult
 

letta/constants.py

@@ -21,6 +21,15 @@ LETTA_CORE_TOOL_MODULE_NAME = "letta.functions.function_sets.base"
 LETTA_MULTI_AGENT_TOOL_MODULE_NAME = "letta.functions.function_sets.multi_agent"
 LETTA_VOICE_TOOL_MODULE_NAME = "letta.functions.function_sets.voice"
 LETTA_BUILTIN_TOOL_MODULE_NAME = "letta.functions.function_sets.builtin"
+LETTA_FILES_TOOL_MODULE_NAME = "letta.functions.function_sets.files"
+
+LETTA_TOOL_MODULE_NAMES = [
+    LETTA_CORE_TOOL_MODULE_NAME,
+    LETTA_MULTI_AGENT_TOOL_MODULE_NAME,
+    LETTA_VOICE_TOOL_MODULE_NAME,
+    LETTA_BUILTIN_TOOL_MODULE_NAME,
+    LETTA_FILES_TOOL_MODULE_NAME,
+]
 
 
 # String in the error message for when the context window is too large
@@ -112,6 +121,9 @@ MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(
 # Built in tools
 BUILTIN_TOOLS = ["run_code", "web_search"]
 
+# Built in tools
+FILES_TOOLS = ["open_file", "close_file", "grep", "search_files"]
+
 # Set of all built-in Letta tools
 LETTA_TOOL_SET = set(
     BASE_TOOLS
@@ -121,6 +133,7 @@ LETTA_TOOL_SET = set(
     + BASE_VOICE_SLEEPTIME_TOOLS
     + BASE_VOICE_SLEEPTIME_CHAT_TOOLS
     + BUILTIN_TOOLS
+    + FILES_TOOLS
 )
 
 
@@ -294,6 +307,7 @@ CORE_MEMORY_SOURCE_CHAR_LIMIT: int = 5000
 # Function return limits
 FUNCTION_RETURN_CHAR_LIMIT = 6000  # ~300 words
 BASE_FUNCTION_RETURN_CHAR_LIMIT = 1000000  # very high (we rely on implementation)
+FILE_IS_TRUNCATED_WARNING = "# NOTE: This block is truncated, use functions to view the full content."
 
 MAX_PAUSE_HEARTBEATS = 360  # in min
 
@@ -316,3 +330,7 @@ RESERVED_FILENAMES = {"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "LPT1", "LPT2"
 WEB_SEARCH_CLIP_CONTENT = False
 WEB_SEARCH_INCLUDE_SCORE = False
 WEB_SEARCH_SEPARATOR = "\n" + "-" * 40 + "\n"
+
+REDIS_INCLUDE = "INCLUDE"
+REDIS_EXCLUDE = "EXCLUDE"
+REDIS_SET_DEFAULT_VAL = "None"