letta-nightly 0.8.4.dev20250615104252__py3-none-any.whl → 0.8.4.dev20250615221417__py3-none-any.whl

letta/__init__.py

@@ -17,6 +17,7 @@ from letta.schemas.enums import JobStatus
 from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.letta_message import LettaMessage
+from letta.schemas.letta_stop_reason import LettaStopReason
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, BasicBlockMemory, ChatMemory, Memory, RecallMemorySummary
 from letta.schemas.message import Message

letta/agents/base_agent.py

@@ -12,7 +12,9 @@ from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
+from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
+from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.helpers.agent_manager_helper import compile_system_message
@@ -116,7 +118,7 @@ class BaseAgent(ABC):
                 system_prompt=agent_state.system,
                 in_context_memory=agent_state.memory,
                 in_context_memory_last_edit=memory_edit_timestamp,
-                previous_message_count=num_messages,
+                previous_message_count=num_messages - len(in_context_messages),
                 archival_memory_size=num_archival_memories,
                 tool_rules_solver=tool_rules_solver,
             )
@@ -136,3 +138,12 @@ class BaseAgent(ABC):
         except:
             logger.exception(f"Failed to rebuild memory for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name})")
             raise
+
+    def get_finish_chunks_for_stream(self, usage: LettaUsageStatistics, stop_reason: Optional[LettaStopReason] = None):
+        if stop_reason is None:
+            stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
+        return [
+            stop_reason.model_dump_json(),
+            usage.model_dump_json(),
+            MessageStreamStatus.done.value,
+        ]

letta/agents/helpers.py

@@ -5,6 +5,7 @@ from typing import List, Optional, Tuple
 from letta.schemas.agent import AgentState
 from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_response import LettaResponse
+from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
@@ -16,6 +17,7 @@ def _create_letta_response(
     new_in_context_messages: list[Message],
     use_assistant_message: bool,
     usage: LettaUsageStatistics,
+    stop_reason: Optional[LettaStopReason] = None,
     include_return_message_types: Optional[List[MessageType]] = None,
 ) -> LettaResponse:
     """
@@ -32,8 +34,9 @@ def _create_letta_response(
     # Apply message type filtering if specified
     if include_return_message_types is not None:
         response_messages = [msg for msg in response_messages if msg.message_type in include_return_message_types]
-
-    return LettaResponse(messages=response_messages, usage=usage)
+    if stop_reason is None:
+        stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
+    return LettaResponse(messages=response_messages, stop_reason=stop_reason, usage=usage)
 
 
 def _prepare_in_context_messages(

letta/agents/letta_agent.py

@@ -5,6 +5,7 @@ from typing import AsyncGenerator, Dict, List, Optional, Tuple, Union
 
 from openai import AsyncStream
 from openai.types.chat import ChatCompletionChunk
+from opentelemetry.trace import Span
 
 from letta.agents.base_agent import BaseAgent
 from letta.agents.ephemeral_summary_agent import EphemeralSummaryAgent
@@ -25,10 +26,11 @@ 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.enums import MessageRole
 from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_response import LettaResponse
+from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatistics
@@ -124,7 +126,7 @@ class LettaAgent(BaseAgent):
         agent_state = await self.agent_manager.get_agent_by_id_async(
             agent_id=self.agent_id, include_relationships=["tools", "memory", "tool_exec_environment_variables"], actor=self.actor
         )
-        _, new_in_context_messages, usage = await self._step(
+        _, new_in_context_messages, usage, stop_reason = await self._step(
             agent_state=agent_state,
             input_messages=input_messages,
             max_steps=max_steps,
@@ -133,6 +135,7 @@ class LettaAgent(BaseAgent):
         return _create_letta_response(
             new_in_context_messages=new_in_context_messages,
             use_assistant_message=use_assistant_message,
+            stop_reason=stop_reason,
             usage=usage,
             include_return_message_types=include_return_message_types,
         )
@@ -159,6 +162,7 @@ class LettaAgent(BaseAgent):
             put_inner_thoughts_first=True,
             actor=self.actor,
         )
+        stop_reason = None
         usage = LettaUsageStatistics()
 
         # span for request
@@ -178,17 +182,13 @@ class LettaAgent(BaseAgent):
                     agent_state,
                     llm_client,
                     tool_rules_solver,
+                    agent_step_span,
                 )
             )
             in_context_messages = current_in_context_messages + new_in_context_messages
 
             log_event("agent.stream_no_tokens.llm_response.received")  # [3^]
 
-            # 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": ns_to_ms(llm_request_ns)})
-
             response = llm_client.convert_response_to_chat_completion(response_data, in_context_messages, agent_state.llm_config)
 
             # update usage
@@ -197,6 +197,9 @@ class LettaAgent(BaseAgent):
             usage.completion_tokens += response.usage.completion_tokens
             usage.prompt_tokens += response.usage.prompt_tokens
             usage.total_tokens += response.usage.total_tokens
+            MetricRegistry().message_output_tokens.record(
+                response.usage.completion_tokens, dict(get_ctx_attributes(), **{"model.name": agent_state.llm_config.model})
+            )
 
             if not response.choices[0].message.tool_calls:
                 # TODO: make into a real error
@@ -210,18 +213,15 @@ class LettaAgent(BaseAgent):
                         signature=response.choices[0].message.reasoning_content_signature,
                     )
                 ]
+            elif response.choices[0].message.omitted_reasoning_content:
+                reasoning = [OmittedReasoningContent()]
             elif response.choices[0].message.content:
                 reasoning = [TextContent(text=response.choices[0].message.content)]  # reasoning placed into content for legacy reasons
             else:
                 logger.info("No reasoning content found.")
                 reasoning = None
 
-            # 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": ns_to_ms(llm_request_ns)})
-
-            persisted_messages, should_continue = await self._handle_ai_response(
+            persisted_messages, should_continue, stop_reason = await self._handle_ai_response(
                 tool_call,
                 valid_tool_names,
                 agent_state,
@@ -262,11 +262,11 @@ class LettaAgent(BaseAgent):
             )
 
             for message in letta_messages:
-                if not include_return_message_types:
-                    yield f"data: {message.model_dump_json()}\n\n"
-                elif include_return_message_types and message.message_type in include_return_message_types:
+                if include_return_message_types is None or message.message_type in include_return_message_types:
                     yield f"data: {message.model_dump_json()}\n\n"
 
+            MetricRegistry().step_execution_time_ms_histogram.record(step_start - get_utc_timestamp_ns(), get_ctx_attributes())
+
             if not should_continue:
                 break
 
@@ -288,8 +288,8 @@ class LettaAgent(BaseAgent):
         request_span.end()
 
         # Return back usage
-        yield f"data: {usage.model_dump_json()}\n\n"
-        yield f"data: {MessageStreamStatus.done.model_dump_json()}\n\n"
+        for finish_chunk in self.get_finish_chunks_for_stream(usage, stop_reason):
+            yield f"data: {finish_chunk}\n\n"
 
     async def _step(
         self,
@@ -297,7 +297,7 @@ class LettaAgent(BaseAgent):
         input_messages: List[MessageCreate],
         max_steps: int = DEFAULT_MAX_STEPS,
         request_start_timestamp_ns: Optional[int] = None,
-    ) -> Tuple[List[Message], List[Message], LettaUsageStatistics]:
+    ) -> Tuple[List[Message], List[Message], Optional[LettaStopReason], LettaUsageStatistics]:
         """
         Carries out an invocation of the agent loop. In each step, the agent
             1. Rebuilds its memory
@@ -320,6 +320,7 @@ class LettaAgent(BaseAgent):
         request_span = tracer.start_span("time_to_first_token")
         request_span.set_attributes({f"llm_config.{k}": v for k, v in agent_state.llm_config.model_dump().items() if v is not None})
 
+        stop_reason = None
         usage = LettaUsageStatistics()
         for i in range(max_steps):
             step_id = generate_step_id()
@@ -329,7 +330,7 @@ class LettaAgent(BaseAgent):
 
             request_data, response_data, current_in_context_messages, new_in_context_messages, valid_tool_names = (
                 await self._build_and_request_from_llm(
-                    current_in_context_messages, new_in_context_messages, agent_state, llm_client, tool_rules_solver
+                    current_in_context_messages, new_in_context_messages, agent_state, llm_client, tool_rules_solver, agent_step_span
                 )
             )
             in_context_messages = current_in_context_messages + new_in_context_messages
@@ -338,16 +339,14 @@ class LettaAgent(BaseAgent):
 
             response = llm_client.convert_response_to_chat_completion(response_data, in_context_messages, agent_state.llm_config)
 
-            # 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": ns_to_ms(llm_request_ns)})
-
             # TODO: add run_id
             usage.step_count += 1
             usage.completion_tokens += response.usage.completion_tokens
             usage.prompt_tokens += response.usage.prompt_tokens
             usage.total_tokens += response.usage.total_tokens
+            MetricRegistry().message_output_tokens.record(
+                response.usage.completion_tokens, dict(get_ctx_attributes(), **{"model.name": agent_state.llm_config.model})
+            )
 
             if not response.choices[0].message.tool_calls:
                 # TODO: make into a real error
@@ -363,11 +362,13 @@ class LettaAgent(BaseAgent):
                 ]
             elif response.choices[0].message.content:
                 reasoning = [TextContent(text=response.choices[0].message.content)]  # reasoning placed into content for legacy reasons
+            elif response.choices[0].message.omitted_reasoning_content:
+                reasoning = [OmittedReasoningContent()]
             else:
                 logger.info("No reasoning content found.")
                 reasoning = None
 
-            persisted_messages, should_continue = await self._handle_ai_response(
+            persisted_messages, should_continue, stop_reason = await self._handle_ai_response(
                 tool_call,
                 valid_tool_names,
                 agent_state,
@@ -401,6 +402,8 @@ class LettaAgent(BaseAgent):
                 ),
             )
 
+            MetricRegistry().step_execution_time_ms_histogram.record(step_start - get_utc_timestamp_ns(), get_ctx_attributes())
+
             if not should_continue:
                 break
 
@@ -421,7 +424,7 @@ class LettaAgent(BaseAgent):
                 force=False,
             )
 
-        return current_in_context_messages, new_in_context_messages, usage
+        return current_in_context_messages, new_in_context_messages, usage, stop_reason
 
     @trace_method
     async def step_stream(
@@ -454,30 +457,35 @@ class LettaAgent(BaseAgent):
             put_inner_thoughts_first=True,
             actor=self.actor,
         )
+        stop_reason = None
         usage = LettaUsageStatistics()
         first_chunk, request_span = True, None
         if request_start_timestamp_ns:
             request_span = tracer.start_span("time_to_first_token", start_time=request_start_timestamp_ns)
             request_span.set_attributes({f"llm_config.{k}": v for k, v in agent_state.llm_config.model_dump().items() if v is not None})
 
-        provider_request_start_timestamp_ns = None
         for i in range(max_steps):
             step_id = generate_step_id()
             step_start = get_utc_timestamp_ns()
             agent_step_span = tracer.start_span("agent_step", start_time=step_start)
             agent_step_span.set_attributes({"step_id": step_id})
 
-            request_data, stream, current_in_context_messages, new_in_context_messages, valid_tool_names = (
-                await self._build_and_request_from_llm_streaming(
-                    first_chunk,
-                    agent_step_span,
-                    request_start_timestamp_ns,
-                    current_in_context_messages,
-                    new_in_context_messages,
-                    agent_state,
-                    llm_client,
-                    tool_rules_solver,
-                )
+            (
+                request_data,
+                stream,
+                current_in_context_messages,
+                new_in_context_messages,
+                valid_tool_names,
+                provider_request_start_timestamp_ns,
+            ) = await self._build_and_request_from_llm_streaming(
+                first_chunk,
+                agent_step_span,
+                request_start_timestamp_ns,
+                current_in_context_messages,
+                new_in_context_messages,
+                agent_state,
+                llm_client,
+                tool_rules_solver,
             )
             log_event("agent.stream.llm_response.received")  # [3^]
 
@@ -504,15 +512,17 @@ class LettaAgent(BaseAgent):
                     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": ns_to_ms(ttft_ns)})
+                    metric_attributes = get_ctx_attributes()
+                    metric_attributes["model.name"] = agent_state.llm_config.model
+                    MetricRegistry().ttft_ms_histogram.record(ns_to_ms(ttft_ns), metric_attributes)
                     first_chunk = False
 
-                if include_return_message_types is None:
-                    # return all data
-                    yield f"data: {chunk.model_dump_json()}\n\n"
-                elif include_return_message_types and chunk.message_type in include_return_message_types:
+                if include_return_message_types is None or chunk.message_type in include_return_message_types:
                     # filter down returned data
                     yield f"data: {chunk.model_dump_json()}\n\n"
 
+            stream_end_time_ns = get_utc_timestamp_ns()
+
             # update usage
             usage.step_count += 1
             usage.completion_tokens += interface.output_tokens
@@ -523,14 +533,26 @@ 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": ns_to_ms(llm_request_ns)})
+            llm_request_ms = ns_to_ms(stream_end_time_ns - request_start_timestamp_ns)
+            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ms})
+            MetricRegistry().llm_execution_time_ms_histogram.record(
+                llm_request_ms,
+                dict(get_ctx_attributes(), **{"model.name": agent_state.llm_config.model}),
+            )
 
             # Process resulting stream content
-            tool_call = interface.get_tool_call_object()
+            try:
+                tool_call = interface.get_tool_call_object()
+            except ValueError as e:
+                stop_reason = LettaStopReason(stop_reason=StopReasonType.no_tool_call.value)
+                yield f"data: {stop_reason.model_dump_json()}\n\n"
+                raise e
+            except Exception as e:
+                stop_reason = LettaStopReason(stop_reason=StopReasonType.invalid_tool_call.value)
+                yield f"data: {stop_reason.model_dump_json()}\n\n"
+                raise e
             reasoning_content = interface.get_reasoning_content()
-            persisted_messages, should_continue = await self._handle_ai_response(
+            persisted_messages, should_continue, stop_reason = await self._handle_ai_response(
                 tool_call,
                 valid_tool_names,
                 agent_state,
@@ -590,6 +612,9 @@ class LettaAgent(BaseAgent):
                 if include_return_message_types is None or tool_return.message_type in include_return_message_types:
                     yield f"data: {tool_return.model_dump_json()}\n\n"
 
+            # TODO (cliandy): consolidate and expand with trace
+            MetricRegistry().step_execution_time_ms_histogram.record(step_start - get_utc_timestamp_ns(), get_ctx_attributes())
+
             if not should_continue:
                 break
 
@@ -610,10 +635,10 @@ class LettaAgent(BaseAgent):
             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
-        yield f"data: {usage.model_dump_json()}\n\n"
-        yield f"data: {MessageStreamStatus.done.model_dump_json()}\n\n"
+        for finish_chunk in self.get_finish_chunks_for_stream(usage, stop_reason):
+            yield f"data: {finish_chunk}\n\n"
 
+    # noinspection PyInconsistentReturns
     async def _build_and_request_from_llm(
         self,
         current_in_context_messages: List[Message],
@@ -621,7 +646,8 @@ class LettaAgent(BaseAgent):
         agent_state: AgentState,
         llm_client: LLMClientBase,
         tool_rules_solver: ToolRulesSolver,
-    ) -> Tuple[Dict, Dict, List[Message], List[Message], List[str]]:
+        agent_step_span: "Span",
+    ) -> Tuple[Dict, Dict, List[Message], List[Message], List[str]] | None:
         for attempt in range(self.max_summarization_retries + 1):
             try:
                 log_event("agent.stream_no_tokens.messages.refreshed")
@@ -635,13 +661,15 @@ class LettaAgent(BaseAgent):
                 log_event("agent.stream_no_tokens.llm_request.created")
 
                 async with AsyncTimer() as timer:
+                    # Attempt LLM request
                     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, response, current_in_context_messages, new_in_context_messages, valid_tool_names)
+                agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": timer.elapsed_ms})
+
+                return request_data, response, current_in_context_messages, new_in_context_messages, valid_tool_names
 
             except Exception as e:
                 if attempt == self.max_summarization_retries:
@@ -659,6 +687,7 @@ class LettaAgent(BaseAgent):
                 new_in_context_messages = []
                 log_event(f"agent.stream_no_tokens.retry_attempt.{attempt + 1}")
 
+    # noinspection PyInconsistentReturns
     async def _build_and_request_from_llm_streaming(
         self,
         first_chunk: bool,
@@ -669,7 +698,7 @@ class LettaAgent(BaseAgent):
         agent_state: AgentState,
         llm_client: LLMClientBase,
         tool_rules_solver: ToolRulesSolver,
-    ) -> Tuple[Dict, AsyncStream[ChatCompletionChunk], List[Message], List[Message], List[str]]:
+    ) -> Tuple[Dict, AsyncStream[ChatCompletionChunk], List[Message], List[Message], List[str], int] | None:
         for attempt in range(self.max_summarization_retries + 1):
             try:
                 log_event("agent.stream_no_tokens.messages.refreshed")
@@ -682,10 +711,13 @@ class LettaAgent(BaseAgent):
                 )
                 log_event("agent.stream.llm_request.created")  # [2^]
 
+                provider_request_start_timestamp_ns = get_utc_timestamp_ns()
                 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": ns_to_ms(provider_req_start_ns)})
+                    request_start_to_provider_request_start_ns = provider_request_start_timestamp_ns - request_start_timestamp_ns
+                    ttft_span.add_event(
+                        name="request_start_to_provider_request_start_ns",
+                        attributes={"request_start_to_provider_request_start_ns": ns_to_ms(request_start_to_provider_request_start_ns)},
+                    )
 
                 # Attempt LLM request
                 return (
@@ -694,6 +726,7 @@ class LettaAgent(BaseAgent):
                     current_in_context_messages,
                     new_in_context_messages,
                     valid_tool_names,
+                    provider_request_start_timestamp_ns,
                 )
 
             except Exception as e:
@@ -709,7 +742,7 @@ class LettaAgent(BaseAgent):
                     llm_config=agent_state.llm_config,
                     force=True,
                 )
-                new_in_context_messages = []
+                new_in_context_messages: list[Message] = []
                 log_event(f"agent.stream_no_tokens.retry_attempt.{attempt + 1}")
 
     @trace_method
@@ -857,12 +890,13 @@ class LettaAgent(BaseAgent):
         initial_messages: Optional[List[Message]] = None,
         agent_step_span: Optional["Span"] = None,
         is_final_step: Optional[bool] = None,
-    ) -> Tuple[List[Message], bool]:
+    ) -> Tuple[List[Message], bool, Optional[LettaStopReason]]:
         """
         Now that streaming is done, handle the final AI response.
         This might yield additional SSE tokens if we do stalling.
         At the end, set self._continue_execution accordingly.
         """
+        stop_reason = None
         # Check if the called tool is allowed by tool name:
         tool_call_name = tool_call.function.name
         tool_call_args_str = tool_call.function.arguments
@@ -880,6 +914,7 @@ class LettaAgent(BaseAgent):
             tool_args = json.loads(tool_args)
 
         if is_final_step:
+            stop_reason = LettaStopReason(stop_reason=StopReasonType.max_steps.value)
             logger.info("Agent has reached max steps.")
             request_heartbeat = False
         else:
@@ -948,6 +983,8 @@ class LettaAgent(BaseAgent):
         continue_stepping = request_heartbeat
         tool_rules_solver.register_tool_call(tool_name=tool_call_name)
         if tool_rules_solver.is_terminal_tool(tool_name=tool_call_name):
+            if continue_stepping:
+                stop_reason = LettaStopReason(stop_reason=StopReasonType.tool_rule.value)
             continue_stepping = False
         elif tool_rules_solver.has_children_tools(tool_name=tool_call_name):
             continue_stepping = True
@@ -994,7 +1031,7 @@ class LettaAgent(BaseAgent):
         )
         self.last_function_response = function_response
 
-        return persisted_messages, continue_stepping
+        return persisted_messages, continue_stepping, stop_reason
 
     @trace_method
     async def _execute_tool(

letta/agents/voice_sleeptime_agent.py

@@ -82,7 +82,7 @@ class VoiceSleeptimeAgent(LettaAgent):
         ]
 
         # Summarize
-        current_in_context_messages, new_in_context_messages, usage = await super()._step(
+        current_in_context_messages, new_in_context_messages, usage, stop_reason = await super()._step(
             agent_state=agent_state, input_messages=input_messages, max_steps=max_steps
         )
         new_in_context_messages, updated = self.summarizer.summarize(
@@ -95,6 +95,7 @@ class VoiceSleeptimeAgent(LettaAgent):
         return _create_letta_response(
             new_in_context_messages=new_in_context_messages,
             use_assistant_message=use_assistant_message,
+            stop_reason=stop_reason,
             usage=usage,
             include_return_message_types=include_return_message_types,
         )

letta/constants.py

@@ -292,9 +292,6 @@ MESSAGE_SUMMARY_WARNING_STR = " ".join(
         # "Remember to pass request_heartbeat = true if you would like to send a message immediately after.",
     ]
 )
-DATA_SOURCE_ATTACH_ALERT = (
-    "[ALERT] New data was just uploaded to archival memory. You can view this data by calling the archival_memory_search tool."
-)
 
 # Throw an error message when a read-only block is edited
 READ_ONLY_BLOCK_EDIT_ERROR = f"{ERROR_MESSAGE_PREFIX} This block is read-only and cannot be edited."
@@ -337,6 +334,7 @@ WEB_SEARCH_CLIP_CONTENT = False
 WEB_SEARCH_INCLUDE_SCORE = False
 WEB_SEARCH_SEPARATOR = "\n" + "-" * 40 + "\n"
 
-REDIS_INCLUDE = "INCLUDE"
-REDIS_EXCLUDE = "EXCLUDE"
+REDIS_INCLUDE = "include"
+REDIS_EXCLUDE = "exclude"
 REDIS_SET_DEFAULT_VAL = "None"
+REDIS_DEFAULT_CACHE_PREFIX = "letta_cache"

letta/data_sources/redis_client.py

@@ -2,12 +2,17 @@ import asyncio
 from functools import wraps
 from typing import Any, Optional, Set, Union
 
-import redis.asyncio as redis
-from redis import RedisError
-
 from letta.constants import REDIS_EXCLUDE, REDIS_INCLUDE, REDIS_SET_DEFAULT_VAL
 from letta.log import get_logger
 
+try:
+    from redis import RedisError
+    from redis.asyncio import ConnectionPool, Redis
+except ImportError:
+    RedisError = None
+    Redis = None
+    ConnectionPool = None
+
 logger = get_logger(__name__)
 
 _client_instance = None
@@ -44,7 +49,7 @@ class AsyncRedisClient:
             retry_on_timeout: Retry operations on timeout
             health_check_interval: Seconds between health checks
         """
-        self.pool = redis.ConnectionPool(
+        self.pool = ConnectionPool(
             host=host,
             port=port,
             db=db,
@@ -59,12 +64,12 @@ class AsyncRedisClient:
         self._client = None
         self._lock = asyncio.Lock()
 
-    async def get_client(self) -> redis.Redis:
+    async def get_client(self) -> Redis:
         """Get or create Redis client instance."""
         if self._client is None:
             async with self._lock:
                 if self._client is None:
-                    self._client = redis.Redis(connection_pool=self.pool)
+                    self._client = Redis(connection_pool=self.pool)
         return self._client
 
     async def close(self):
@@ -213,8 +218,8 @@ class AsyncRedisClient:
         return await client.decr(key)
 
     async def check_inclusion_and_exclusion(self, member: str, group: str) -> bool:
-        exclude_key = f"{group}_{REDIS_EXCLUDE}"
-        include_key = f"{group}_{REDIS_INCLUDE}"
+        exclude_key = self._get_group_exclusion_key(group)
+        include_key = self._get_group_inclusion_key(group)
         # 1. if the member IS excluded from the group
         if self.exists(exclude_key) and await self.scard(exclude_key) > 1:
             return bool(await self.smismember(exclude_key, member))
@@ -231,14 +236,29 @@ class AsyncRedisClient:
 
     @staticmethod
     def _get_group_inclusion_key(group: str) -> str:
-        return f"{group}_{REDIS_INCLUDE}"
+        return f"{group}:{REDIS_INCLUDE}"
 
     @staticmethod
     def _get_group_exclusion_key(group: str) -> str:
-        return f"{group}_{REDIS_EXCLUDE}"
+        return f"{group}:{REDIS_EXCLUDE}"
 
 
 class NoopAsyncRedisClient(AsyncRedisClient):
+    # noinspection PyMissingConstructor
+    def __init__(self):
+        pass
+
+    async def set(
+        self,
+        key: str,
+        value: Union[str, int, float],
+        ex: Optional[int] = None,
+        px: Optional[int] = None,
+        nx: bool = False,
+        xx: bool = False,
+    ) -> bool:
+        return False
+
     async def get(self, key: str, default: Any = None) -> Any:
         return default
 

letta/functions/function_sets/files.py

@@ -7,10 +7,10 @@ if TYPE_CHECKING:
 
 async def open_file(agent_state: "AgentState", file_name: str, view_range: Optional[Tuple[int, int]]) -> str:
     """
-    Open up a file in core memory.
+    Open the file with name `file_name` and load the contents into files section in core memory.
 
     Args:
-        file_name (str): Name of the file to view.
+        file_name (str): Name of the file to view. Required.
         view_range (Optional[Tuple[int, int]]): Optional tuple indicating range to view.
 
     Returns:
@@ -21,7 +21,7 @@ async def open_file(agent_state: "AgentState", file_name: str, view_range: Optio
 
 async def close_file(agent_state: "AgentState", file_name: str) -> str:
     """
-    Close a file in core memory.
+    Close file with name `file_name` in files section in core memory.
 
     Args:
         file_name (str): Name of the file to close.
@@ -48,7 +48,7 @@ async def grep(agent_state: "AgentState", pattern: str, include: Optional[str] =
 
 async def search_files(agent_state: "AgentState", query: str) -> List["FileMetadata"]:
     """
-    Get list of most relevant files across all data sources.
+    Get list of most relevant files across all data sources using embedding search.
 
     Args:
         query (str): The search query.