letta-nightly 0.7.6.dev20250430104233__py3-none-any.whl → 0.7.8.dev20250501064110__py3-none-any.whl

letta/agents/{ephemeral_memory_agent.py → voice_sleeptime_agent.py}

@@ -1,6 +1,6 @@
 import json
 import xml.etree.ElementTree as ET
-from typing import AsyncGenerator, Dict, List, Tuple, Union
+from typing import AsyncGenerator, Dict, List, Optional, Tuple, Union
 
 import openai
 
@@ -11,17 +11,19 @@ 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.message import MessageCreate
-from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, SystemMessage, Tool, UserMessage
+from letta.schemas.message import Message, MessageCreate, ToolReturn
+from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool, UserMessage
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.server.rest_api.utils import convert_in_context_letta_messages_to_openai, create_input_messages
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
 from letta.services.message_manager import MessageManager
+from letta.system import package_function_response
 
 
-class EphemeralMemoryAgent(BaseAgent):
+# TODO: Move this to the new Letta Agent loop
+class VoiceSleeptimeAgent(BaseAgent):
     """
     A stateless agent that helps with offline memory computations.
     """
@@ -29,6 +31,7 @@ class EphemeralMemoryAgent(BaseAgent):
     def __init__(
         self,
         agent_id: str,
+        convo_agent_state: AgentState,
         openai_client: openai.AsyncClient,
         message_manager: MessageManager,
         agent_manager: AgentManager,
@@ -45,6 +48,7 @@ class EphemeralMemoryAgent(BaseAgent):
             actor=actor,
         )
 
+        self.convo_agent_state = convo_agent_state
         self.block_manager = block_manager
         self.target_block_label = target_block_label
         self.message_transcripts = message_transcripts
@@ -62,9 +66,7 @@ class EphemeralMemoryAgent(BaseAgent):
         openai_messages = convert_in_context_letta_messages_to_openai(in_context_messages, exclude_system_messages=True)
 
         # 1. Store memories
-        request = self._build_openai_request(
-            openai_messages, agent_state, tools=self._build_store_memory_tool_schemas(), system=self._get_memory_store_system_prompt()
-        )
+        request = self._build_openai_request(openai_messages, agent_state, tools=self._build_store_memory_tool_schemas())
 
         chat_completion = await self.openai_client.chat.completions.create(**request.model_dump(exclude_unset=True))
         assistant_message = chat_completion.choices[0].message
@@ -74,29 +76,53 @@ class EphemeralMemoryAgent(BaseAgent):
         function_name = tool_call.function.name
         function_args = json.loads(tool_call.function.arguments)
 
-        if function_name == "store_memory":
-            print("Called store_memory")
+        if function_name == "store_memories":
+            print("Called store_memories")
             print(function_args)
-            for chunk_args in function_args.get("chunks"):
-                self.store_memory(agent_state=agent_state, **chunk_args)
-            result = "Successfully stored memories"
+            chunks = function_args.get("chunks", [])
+            results = [self.store_memory(agent_state=self.convo_agent_state, **chunk_args) for chunk_args in chunks]
+
+            aggregated_result = next((res for res, _ in results if res is not None), None)
+            aggregated_success = all(success for _, success in results)
+
         else:
             raise ValueError("Error: Unknown tool function '{function_name}'")
 
-        openai_messages.append(
-            {
-                "role": "assistant",
-                "content": assistant_message.content,
-                "tool_calls": [
-                    {
-                        "id": tool_call.id,
-                        "type": "function",
-                        "function": {"name": function_name, "arguments": tool_call.function.arguments},
-                    }
-                ],
-            }
+        assistant_message = {
+            "role": "assistant",
+            "content": assistant_message.content,
+            "tool_calls": [
+                {
+                    "id": tool_call.id,
+                    "type": "function",
+                    "function": {"name": function_name, "arguments": tool_call.function.arguments},
+                }
+            ],
+        }
+        openai_messages.append(assistant_message)
+        in_context_messages.append(
+            Message.dict_to_message(
+                agent_id=self.agent_id,
+                openai_message_dict=assistant_message,
+                model=agent_state.llm_config.model,
+                name=function_name,
+            )
+        )
+        tool_call_message = {
+            "role": "tool",
+            "tool_call_id": tool_call.id,
+            "content": package_function_response(was_success=aggregated_success, response_string=str(aggregated_result)),
+        }
+        openai_messages.append(tool_call_message)
+        in_context_messages.append(
+            Message.dict_to_message(
+                agent_id=self.agent_id,
+                openai_message_dict=tool_call_message,
+                model=agent_state.llm_config.model,
+                name=function_name,
+                tool_returns=[ToolReturn(status="success" if aggregated_success else "error")],
+            )
         )
-        openai_messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(result)})
 
         # 2. Execute rethink block memory loop
         human_block_content = self.agent_manager.get_block_with_label(
@@ -115,15 +141,13 @@ Please refine this block:
 - Organize related information together (e.g., preferences, background, ongoing goals).
 - Add any light, supportable inferences that deepen understanding—but do not invent unsupported details.
 
-Use `rethink_memory(new_memory)` as many times as you need to iteratively improve the text. When it’s fully polished and complete, call `finish_rethinking_memory()`.
+Use `rethink_user_memory(new_memory)` as many times as you need to iteratively improve the text. When it’s fully polished and complete, call `finish_rethinking_memory()`.
         """
         rethink_command = UserMessage(content=rethink_command)
         openai_messages.append(rethink_command.model_dump())
 
         for _ in range(max_steps):
-            request = self._build_openai_request(
-                openai_messages, agent_state, tools=self._build_sleeptime_tools(), system=self._get_rethink_memory_system_prompt()
-            )
+            request = self._build_openai_request(openai_messages, agent_state, tools=self._build_sleeptime_tools())
             chat_completion = await self.openai_client.chat.completions.create(**request.model_dump(exclude_unset=True))
             assistant_message = chat_completion.choices[0].message
 
@@ -132,35 +156,59 @@ Use `rethink_memory(new_memory)` as many times as you need to iteratively improv
             function_name = tool_call.function.name
             function_args = json.loads(tool_call.function.arguments)
 
-            if function_name == "rethink_memory":
-                print("Called rethink_memory")
+            if function_name == "rethink_user_memory":
+                print("Called rethink_user_memory")
                 print(function_args)
-                result = self.rethink_memory(agent_state=agent_state, **function_args)
+                result, success = self.rethink_user_memory(agent_state=agent_state, **function_args)
             elif function_name == "finish_rethinking_memory":
                 print("Called finish_rethinking_memory")
+                result, success = None, True
                 break
             else:
-                result = f"Error: Unknown tool function '{function_name}'"
-            openai_messages.append(
-                {
-                    "role": "assistant",
-                    "content": assistant_message.content,
-                    "tool_calls": [
-                        {
-                            "id": tool_call.id,
-                            "type": "function",
-                            "function": {"name": function_name, "arguments": tool_call.function.arguments},
-                        }
-                    ],
-                }
+                print(f"Error: Unknown tool function '{function_name}'")
+                raise ValueError(f"Error: Unknown tool function '{function_name}'", False)
+            assistant_message = {
+                "role": "assistant",
+                "content": assistant_message.content,
+                "tool_calls": [
+                    {
+                        "id": tool_call.id,
+                        "type": "function",
+                        "function": {"name": function_name, "arguments": tool_call.function.arguments},
+                    }
+                ],
+            }
+            openai_messages.append(assistant_message)
+            in_context_messages.append(
+                Message.dict_to_message(
+                    agent_id=self.agent_id,
+                    openai_message_dict=assistant_message,
+                    model=agent_state.llm_config.model,
+                    name=function_name,
+                )
+            )
+            tool_call_message = {
+                "role": "tool",
+                "tool_call_id": tool_call.id,
+                "content": package_function_response(was_success=success, response_string=str(result)),
+            }
+            openai_messages.append(tool_call_message)
+            in_context_messages.append(
+                Message.dict_to_message(
+                    agent_id=self.agent_id,
+                    openai_message_dict=tool_call_message,
+                    model=agent_state.llm_config.model,
+                    name=function_name,
+                    tool_returns=[ToolReturn(status="success" if success else "error")],
+                )
             )
-            openai_messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(result)})
 
         # Actually save the memory:
         target_block = agent_state.memory.get_block(self.target_block_label)
         self.block_manager.update_block(block_id=target_block.id, block_update=BlockUpdate(value=target_block.value), actor=self.actor)
 
-        return LettaResponse(messages=[], usage=LettaUsageStatistics())
+        self.message_manager.create_many_messages(pydantic_msgs=in_context_messages, actor=self.actor)
+        return LettaResponse(messages=[msg for m in in_context_messages for msg in m.to_letta_messages()], usage=LettaUsageStatistics())
 
     def _format_messages_llm_friendly(self):
         messages = self.message_manager.list_messages_for_agent(agent_id=self.agent_id, actor=self.actor)
@@ -168,13 +216,10 @@ Use `rethink_memory(new_memory)` as many times as you need to iteratively improv
         llm_friendly_messages = [f"{m.role}: {m.content[0].text}" for m in messages if m.content and isinstance(m.content[0], TextContent)]
         return "\n".join(llm_friendly_messages)
 
-    def _build_openai_request(
-        self, openai_messages: List[Dict], agent_state: AgentState, tools: List[Tool], system: str
-    ) -> ChatCompletionRequest:
-        system_message = SystemMessage(role="system", content=system)
+    def _build_openai_request(self, openai_messages: List[Dict], agent_state: AgentState, tools: List[Tool]) -> ChatCompletionRequest:
         openai_request = ChatCompletionRequest(
-            model="gpt-4o",  # agent_state.llm_config.model, # TODO: Separate config for summarizer?
-            messages=[system_message] + openai_messages,
+            model=agent_state.llm_config.model,  # TODO: Separate config for summarizer?
+            messages=openai_messages,
             tools=tools,
             tool_choice="required",
             user=self.actor.id,
@@ -192,7 +237,7 @@ Use `rethink_memory(new_memory)` as many times as you need to iteratively improv
             Tool(
                 type="function",
                 function={
-                    "name": "store_memory",
+                    "name": "store_memories",
                     "description": "Archive coherent chunks of dialogue that will be evicted, preserving raw lines and a brief contextual description.",
                     "parameters": {
                         "type": "object",
@@ -227,7 +272,7 @@ Use `rethink_memory(new_memory)` as many times as you need to iteratively improv
             Tool(
                 type="function",
                 function={
-                    "name": "rethink_memory",
+                    "name": "rethink_user_memory",
                     "description": (
                         "Rewrite memory block for the main agent, new_memory should contain all current "
                         "information from the block that is not outdated or inconsistent, integrating any "
@@ -268,14 +313,14 @@ Use `rethink_memory(new_memory)` as many times as you need to iteratively improv
 
         return tools
 
-    def rethink_memory(self, new_memory: str, agent_state: AgentState) -> str:
+    def rethink_user_memory(self, new_memory: str, agent_state: AgentState) -> Tuple[Optional[str], bool]:
         if agent_state.memory.get_block(self.target_block_label) is None:
             agent_state.memory.create_block(label=self.target_block_label, value=new_memory)
 
         agent_state.memory.update_block_value(label=self.target_block_label, value=new_memory)
-        return "Successfully updated memory"
+        return None, True
 
-    def store_memory(self, start_index: int, end_index: int, context: str, agent_state: AgentState) -> str:
+    def store_memory(self, start_index: int, end_index: int, context: str, agent_state: AgentState) -> Tuple[Optional[str], bool]:
         """
         Store a memory.
         """
@@ -290,9 +335,9 @@ Use `rethink_memory(new_memory)` as many times as you need to iteratively improv
             )
             self.agent_manager.rebuild_system_prompt(agent_id=agent_state.id, actor=self.actor, force=True)
 
-            return "Sucessfully stored memory"
+            return None, True
         except Exception as e:
-            return f"Failed to store memory given start_index {start_index} and end_index {end_index}: {e}"
+            return f"Failed to store memory given start_index {start_index} and end_index {end_index}: {e}", False
 
     def serialize(self, messages: List[str], context: str) -> str:
         """
@@ -351,72 +396,4 @@ Use `rethink_memory(new_memory)` as many times as you need to iteratively improv
         """
         This agent is synchronous-only. If called in an async context, raise an error.
         """
-        raise NotImplementedError("EphemeralMemoryAgent does not support async step.")
-
-    # TODO: Move these to independent text files
-    def _get_memory_store_system_prompt(self) -> str:
-        return """
-You are a memory-recall assistant working asynchronously alongside a main chat agent that retains only a portion of the message history in its context window.
-
-When given a full transcript with lines marked (Older) or (Newer), you should:
-1. Segment the (Older) portion into coherent chunks by topic, instruction, or preference.
-2. For each chunk, produce only:
-   - start_index: the first line’s index
-   - end_index:   the last line’s index
-   - context: a blurb explaining why this chunk matters
-
-Return exactly one JSON tool call to `store_memory`, consider this miniature example:
-
----
-
-(Older)
-0. user: Okay. Got it. Keep your answers shorter, please.
-1. assistant: Sure thing! I’ll keep it brief. What would you like to know?
-2. user: I like basketball.
-3. assistant: That's great! Do you have a favorite team or player?
-
-(Newer)
-4. user: Yeah. I like basketball.
-5. assistant: Awesome! What do you enjoy most about basketball?
-
----
-
-Example output:
-
-```json
-{
-  "name": "store_memory",
-  "arguments": {
-    "chunks": [
-      {
-        "start_index": 0,
-        "end_index": 1,
-        "context": "User explicitly asked the assistant to keep responses concise."
-      },
-      {
-        "start_index": 2,
-        "end_index": 3,
-        "context": "User enjoys basketball and prompted follow-up about their favorite team or player."
-      }
-    ]
-  }
-}
-```
-    """
-
-    def _get_rethink_memory_system_prompt(self) -> str:
-        return """
-SYSTEM
-You are a Memory-Updater agent. Your job is to iteratively refine the given memory block until it’s concise, organized, and complete.
-
-Instructions:
-- Call `rethink_memory(new_memory: string)` as many times as you like. Each call should submit a fully revised version of the block so far.
-- When you’re fully satisfied, call `finish_rethinking_memory()`.
-- Don’t output anything else—only the JSON for these tool calls.
-
-Goals:
-- Merge in new facts and remove contradictions.
-- Group related details (preferences, biography, goals).
-- Draw light, supportable inferences without inventing facts.
-- Preserve every critical piece of information.
-    """
+        raise NotImplementedError("VoiceSleeptimeAgent does not support async step.")

letta/client/client.py

@@ -1031,7 +1031,7 @@ class RESTClient(AbstractClient):
             #     messages = []
             #     for m in response.messages:
             #         assert isinstance(m, Message)
-            #         messages += m.to_letta_message()
+            #         messages += m.to_letta_messages()
             #     response.messages = messages
 
             return response
@@ -2725,14 +2725,14 @@ class LocalClient(AbstractClient):
         #    assert isinstance(m, Message), f"Expected Message object, got {type(m)}"
         # letta_messages = []
         # for m in messages:
-        #    letta_messages += m.to_letta_message()
+        #    letta_messages += m.to_letta_messages()
         # return LettaResponse(messages=letta_messages, usage=usage)
 
         # format messages
         messages = self.interface.to_list()
         letta_messages = []
         for m in messages:
-            letta_messages += m.to_letta_message()
+            letta_messages += m.to_letta_messages()
 
         return LettaResponse(messages=letta_messages, usage=usage)
 

letta/constants.py

@@ -4,7 +4,7 @@ from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
 LETTA_TOOL_EXECUTION_DIR = os.path.join(LETTA_DIR, "tool_execution_dir")
 
-LETTA_MODEL_ENDPOINT = "https://inference.memgpt.ai"
+LETTA_MODEL_ENDPOINT = "https://inference.letta.com"
 
 ADMIN_PREFIX = "/v1/admin"
 API_PREFIX = "/v1"
@@ -18,6 +18,8 @@ MCP_TOOL_TAG_NAME_PREFIX = "mcp"  # full format, mcp:server_name
 
 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"
+
 
 # String in the error message for when the context window is too large
 # Example full message:
@@ -33,6 +35,10 @@ TOOL_CALL_ID_MAX_LEN = 29
 # minimum context window size
 MIN_CONTEXT_WINDOW = 4096
 
+# Voice Sleeptime message buffer lengths
+DEFAULT_MAX_MESSAGE_BUFFER_LENGTH = 30
+DEFAULT_MIN_MESSAGE_BUFFER_LENGTH = 15
+
 # embeddings
 MAX_EMBEDDING_DIM = 4096  # maximum supported embeding size - do NOT change or else DBs will need to be reset
 DEFAULT_EMBEDDING_CHUNK_SIZE = 300
@@ -67,10 +73,20 @@ BASE_SLEEPTIME_TOOLS = [
     # "archival_memory_search",
     # "conversation_search",
 ]
+# Base tools for the voice agent
+BASE_VOICE_SLEEPTIME_CHAT_TOOLS = [SEND_MESSAGE_TOOL_NAME, "search_memory"]
+# Base memory tools for sleeptime agent
+BASE_VOICE_SLEEPTIME_TOOLS = [
+    "store_memories",
+    "rethink_user_memory",
+    "finish_rethinking_memory",
+]
 # Multi agent tools
 MULTI_AGENT_TOOLS = ["send_message_to_agent_and_wait_for_reply", "send_message_to_agents_matching_tags", "send_message_to_agent_async"]
 # Set of all built-in Letta tools
-LETTA_TOOL_SET = set(BASE_TOOLS + BASE_MEMORY_TOOLS + MULTI_AGENT_TOOLS + BASE_SLEEPTIME_TOOLS)
+LETTA_TOOL_SET = set(
+    BASE_TOOLS + BASE_MEMORY_TOOLS + MULTI_AGENT_TOOLS + BASE_SLEEPTIME_TOOLS + BASE_VOICE_SLEEPTIME_TOOLS + BASE_VOICE_SLEEPTIME_CHAT_TOOLS
+)
 
 # The name of the tool used to send message to the user
 # May not be relevant in cases where the agent has multiple ways to message to user (send_imessage, send_discord_mesasge, ...)

letta/functions/composio_helpers.py

@@ -0,0 +1,100 @@
+import asyncio
+import os
+from typing import Any, Optional
+
+from composio import ComposioToolSet
+from composio.constants import DEFAULT_ENTITY_ID
+from composio.exceptions import (
+    ApiKeyNotProvidedError,
+    ComposioSDKError,
+    ConnectedAccountNotFoundError,
+    EnumMetadataNotFound,
+    EnumStringNotFound,
+)
+
+from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY
+
+
+# TODO: This is kind of hacky, as this is used to search up the action later on composio's side
+# TODO: So be very careful changing/removing these pair of functions
+def _generate_func_name_from_composio_action(action_name: str) -> str:
+    """
+    Generates the composio function name from the composio action.
+
+    Args:
+        action_name: The composio action name
+
+    Returns:
+        function name
+    """
+    return action_name.lower()
+
+
+def generate_composio_action_from_func_name(func_name: str) -> str:
+    """
+    Generates the composio action from the composio function name.
+
+    Args:
+        func_name: The composio function name
+
+    Returns:
+        composio action name
+    """
+    return func_name.upper()
+
+
+def generate_composio_tool_wrapper(action_name: str) -> tuple[str, str]:
+    # Generate func name
+    func_name = _generate_func_name_from_composio_action(action_name)
+
+    wrapper_function_str = f"""\
+def {func_name}(**kwargs):
+    raise RuntimeError("Something went wrong - we should never be using the persisted source code for Composio. Please reach out to Letta team")
+"""
+
+    # Compile safety check
+    _assert_code_gen_compilable(wrapper_function_str.strip())
+
+    return func_name, wrapper_function_str.strip()
+
+
+async def execute_composio_action_async(
+    action_name: str, args: dict, api_key: Optional[str] = None, entity_id: Optional[str] = None
+) -> tuple[str, str]:
+    try:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, execute_composio_action, action_name, args, api_key, entity_id)
+    except Exception as e:
+        raise RuntimeError(f"Error in execute_composio_action_async: {e}") from e
+
+
+def execute_composio_action(action_name: str, args: dict, api_key: Optional[str] = None, entity_id: Optional[str] = None) -> Any:
+    entity_id = entity_id or os.getenv(COMPOSIO_ENTITY_ENV_VAR_KEY, DEFAULT_ENTITY_ID)
+    try:
+        composio_toolset = ComposioToolSet(api_key=api_key, entity_id=entity_id, lock=False)
+        response = composio_toolset.execute_action(action=action_name, params=args)
+    except ApiKeyNotProvidedError:
+        raise RuntimeError(
+            f"Composio API key is missing for action '{action_name}'. "
+            "Please set the sandbox environment variables either through the ADE or the API."
+        )
+    except ConnectedAccountNotFoundError:
+        raise RuntimeError(f"No connected account was found for action '{action_name}'. " "Please link an account and try again.")
+    except EnumStringNotFound as e:
+        raise RuntimeError(f"Invalid value provided for action '{action_name}': " + str(e) + ". Please check the action parameters.")
+    except EnumMetadataNotFound as e:
+        raise RuntimeError(f"Invalid value provided for action '{action_name}': " + str(e) + ". Please check the action parameters.")
+    except ComposioSDKError as e:
+        raise RuntimeError(f"An unexpected error occurred in Composio SDK while executing action '{action_name}': " + str(e))
+
+    if "error" in response and response["error"]:
+        raise RuntimeError(f"Error while executing action '{action_name}': " + str(response["error"]))
+
+    return response.get("data")
+
+
+def _assert_code_gen_compilable(code_str):
+    try:
+        compile(code_str, "<string>", "exec")
+    except SyntaxError as e:
+        print(f"Syntax error in code: {e}")

letta/functions/function_sets/base.py

@@ -186,16 +186,6 @@ def rethink_memory(agent_state: "AgentState", new_memory: str, target_block_labe
     return None
 
 
-def finish_rethinking_memory(agent_state: "AgentState") -> None:  # type: ignore
-    """
-    This function is called when the agent is done rethinking the memory.
-
-    Returns:
-        Optional[str]: None is always returned as this function does not produce a response.
-    """
-    return None
-
-
 ## Attempted v2 of sleep-time function set, meant to work better across all types
 
 SNIPPET_LINES: int = 4

letta/functions/function_sets/voice.py

@@ -0,0 +1,92 @@
+## Voice chat + sleeptime tools
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+
+def rethink_user_memory(agent_state: "AgentState", new_memory: str) -> None:
+    """
+    Rewrite memory block for the main agent, new_memory should contain all current
+    information from the block that is not outdated or inconsistent, integrating any
+    new information, resulting in a new memory block that is organized, readable, and
+    comprehensive.
+
+    Args:
+        new_memory (str): The new memory with information integrated from the memory block.
+                          If there is no new information, then this should be the same as
+                          the content in the source block.
+
+    Returns:
+        None: None is always returned as this function does not produce a response.
+    """
+    # This is implemented directly in the agent loop
+    return None
+
+
+def finish_rethinking_memory(agent_state: "AgentState") -> None:  # type: ignore
+    """
+    This function is called when the agent is done rethinking the memory.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    return None
+
+
+class MemoryChunk(BaseModel):
+    start_index: int = Field(..., description="Index of the first line in the original conversation history.")
+    end_index: int = Field(..., description="Index of the last line in the original conversation history.")
+    context: str = Field(..., description="A concise, high-level note explaining why this chunk matters.")
+
+
+def store_memories(agent_state: "AgentState", chunks: List[MemoryChunk]) -> None:
+    """
+    Archive coherent chunks of dialogue that will be evicted, preserving raw lines
+    and a brief contextual description.
+
+    Args:
+        agent_state (AgentState):
+            The agent’s current memory state, exposing both its in-session history
+            and the archival memory API.
+        chunks (List[MemoryChunk]):
+            A list of MemoryChunk models, each representing a segment to archive:
+              • start_index (int): Index of the first line in the original history.
+              • end_index   (int): Index of the last line in the original history.
+              • context     (str): A concise, high-level description of why this chunk
+                                 matters and what it contains.
+
+    Returns:
+        None
+    """
+    # This is implemented directly in the agent loop
+    return None
+
+
+def search_memory(
+    agent_state: "AgentState",
+    convo_keyword_queries: Optional[List[str]],
+    start_minutes_ago: Optional[int],
+    end_minutes_ago: Optional[int],
+) -> Optional[str]:
+    """
+    Look in long-term or earlier-conversation memory only when the user asks about
+    something missing from the visible context. The user’s latest utterance is sent
+    automatically as the main query.
+
+    Args:
+        agent_state (AgentState): The current state of the agent, including its
+            memory stores and context.
+        convo_keyword_queries (Optional[List[str]]): Extra keywords or identifiers
+            (e.g., order ID, place name) to refine the search when the request is vague.
+            Set to None if the user’s utterance is already specific.
+        start_minutes_ago (Optional[int]): Newer bound of the time window for results,
+            specified in minutes ago. Set to None if no lower time bound is needed.
+        end_minutes_ago (Optional[int]): Older bound of the time window for results,
+            specified in minutes ago. Set to None if no upper time bound is needed.
+
+    Returns:
+        Optional[str]: A formatted string of matching memory entries, or None if no
+            relevant memories are found.
+    """
+    # This is implemented directly in the agent loop
+    return None

letta/functions/functions.py

@@ -1,8 +1,9 @@
 import importlib
 import inspect
+from collections.abc import Callable
 from textwrap import dedent  # remove indentation
 from types import ModuleType
-from typing import Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
 
 from letta.errors import LettaToolCreateError
 from letta.functions.schema_generator import generate_schema
@@ -66,7 +67,8 @@ def parse_source_code(func) -> str:
     return source_code
 
 
-def get_function_from_module(module_name: str, function_name: str):
+# TODO (cliandy) refactor below two funcs
+def get_function_from_module(module_name: str, function_name: str) -> Callable[..., Any]:
     """
     Dynamically imports a function from a specified module.