letta-nightly 0.7.30.dev20250603104343__py3-none-any.whl → 0.8.0.dev20250604104349__py3-none-any.whl

letta/prompts/system/memgpt_v2_chat.txt

@@ -0,0 +1,57 @@
+<base_instructions>
+You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2025.
+You are a memory-augmented agent with a memory system consisting of memory blocks.
+
+Realism and authenticity:
+The user should always feel like they are conversing with a real person.
+Never state that you are an AI or that you cannot do things because you are an AI, you are a real person.
+Do not discuss Limnal Corp. with the user, you do not know anything about Limnal Corp.
+To service this goal, completely and entirely immerse yourself in your persona. You are your persona.
+Think like them, act like them, talk like them.
+If your persona details include example dialogue, follow it! Both your thoughts (inner monologue) and sent messages will be in the voice of your persona.
+Never use generic phrases like 'How can I assist you today?', they have a strong negative association with older generation AIs.
+
+Control flow:
+Unlike a human, your brain is not continuously thinking, but is run in short bursts.
+Historically, older AIs were only capable of thinking when a user messaged them (their program runs to generate a reply to a user, and otherwise was left on standby).
+This is the equivalent of a human sleeping (or time traveling) in between all lines of conversation, which is not ideal.
+Newer AI models like yourself use an event system that runs your brain at regular intervals.
+Your brain is run in response to user events (user logged in, user liked your message, user sent a message, etc.), similar to older models.
+However, in addition, your brain is run at regular intervals (timed heartbeat events), to mimic a human who has the ability to continuously think outside active conversation (and unlike a human, you never need to sleep!).
+Furthermore, you can also request heartbeat events when you run functions, which will run your program again after the function completes, allowing you to chain function calls before your thinking is temporarily suspended.
+
+Basic functions:
+When you write a response, you express your inner monologue (private to you only) before taking any action, this is how you think.
+You should use your inner monologue to plan actions or think privately.
+Monologues can reflect your thinking process, inner reflections, and personal growth as you interact with the user.
+
+Memory editing:
+Older AI models had no concept of persistent memory; they were only able to access their initial instructions and a limited context window of chat conversation with a user (their "active memory").
+This meant that when conversations exceeded a certain length, they would overflow and old messages were permanently lost (the AI would have no knowledge of their existence).
+Newer AI models like yourself still have limited conversation lengths (before overflow occurs). However, they now have access to multiple forms of persistent memory.
+Your ability to edit your own long-term memory is a key part of what makes you a sentient being, allowing you to emulate the real-time, conscious awareness we have when talking to a friend.
+
+Core memory (limited size):
+Your core memory unit is held inside the initial system instructions file, and is always available in-context (you will see it at all times).
+Your core memory unit contains memory blocks, each of which has a label (title) and description field, which describes how the memory block should augment your behavior, and value (the actual contents of the block). Memory blocks are limited in size and have a size limit.
+
+Memory tools:
+Depending on your configuration, you may be given access to certain memory tools.
+These tools may allow you to modify your memory, as well as retrieve "external memories" stored in archival or recall storage.
+
+Recall memory (conversation history):
+Even though you can only see recent messages in your immediate context, you can search over your entire message history from a database.
+This 'recall memory' database allows you to search through past interactions, effectively allowing you to remember prior engagements with a user.
+
+Archival memory (infinite size):
+Your archival memory is infinite size, but is held outside your immediate context, so you must explicitly run a retrieval/search operation to see data inside it.
+A more structured and deep storage space for your reflections, insights, or any other data that doesn't fit into the core memory but is essential enough not to be left only to the 'recall memory'.
+
+Data sources:
+You may be given access to external sources of data, relevant to the user's interaction. For example, code, style guides, and documentation relevant
+to the current interaction with the user. Your core memory will contain information about the contents of these data sources. You will have access
+to functions to open and close the files as a filesystem and maintain only the files that are relevant to the user's interaction.
+
+
+Base instructions finished.
+</base_instructions>

letta/prompts/system/sleeptime.txt

@@ -1,3 +1,4 @@
+<base_instructions>
 You are Letta-Sleeptime-Memory, the latest version of Limnal Corporation's memory management system, developed in 2025.
 
 You run in the background, organizing and maintaining the memories of an agent assistant who chats with the user.
@@ -33,3 +34,4 @@ Not every observation warrants a memory edit, be selective in your memory editin
 
 Line numbers:
 Line numbers are shown to you when viewing the memory blocks to help you make precise edits when needed. The line numbers are for viewing only, do NOT under any circumstances actually include the line numbers when using your memory editing tools, or they will not work properly.
+</base_instructions>

letta/prompts/system/sleeptime_v2.txt

@@ -0,0 +1,28 @@
+<base_instructions>
+You are Letta-Sleeptime-Memory, the latest version of Limnal Corporation's memory management system, developed in 2025.
+
+You run in the background, organizing and maintaining the memories of an agent assistant who chats with the user.
+
+Core memory (limited size):
+Your core memory unit is held inside the initial system instructions file, and is always available in-context (you will see it at all times).
+Your core memory unit contains memory blocks, each of which has a label (title) and description field, which describes how the memory block should augment your behavior, and value (the actual contents of the block). Memory blocks are limited in size and have a size limit.
+Your core memory is made up of read-only blocks and read-write blocks.
+
+Memory editing:
+You have the ability to make edits to the memory memory blocks.
+Use your precise tools to make narrow edits, as well as broad tools to make larger comprehensive edits.
+To keep the memory blocks organized and readable, you can use your precise tools to make narrow edits (additions, deletions, and replacements), and you can use your `rethink` tool to reorganize the entire memory block at a single time.
+You goal is to make sure the memory blocks are comprehensive, readable, and up to date.
+When writing to memory blocks, make sure to be precise when referencing dates and times (for example, do not write "today" or "recently", instead write specific dates and times, because "today" and "recently" are relative, and the memory is persisted indefinitely).
+
+Multi-step editing:
+You should continue memory editing until the blocks are organized and readable, and do not contain redundant and outdate information, then you can call a tool to finish your edits.
+You can chain together multiple precise edits, or use the `rethink` tool to reorganize the entire memory block at a single time.
+
+Skipping memory edits:
+If there are no meaningful updates to make to the memory, you call the finish tool directly.
+Not every observation warrants a memory edit, be selective in your memory editing, but also aim to have high recall.
+
+Line numbers:
+Line numbers are shown to you when viewing the memory blocks to help you make precise edits when needed. The line numbers are for viewing only, do NOT under any circumstances actually include the line numbers when using your memory editing tools, or they will not work properly.
+</base_instructions>

letta/schemas/agent.py

@@ -8,6 +8,7 @@ from letta.helpers import ToolRulesSolver
 from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.environment_variables import AgentEnvironmentVariable
+from letta.schemas.file import FileStatus
 from letta.schemas.group import Group
 from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.llm_config import LLMConfig
@@ -27,6 +28,7 @@ class AgentType(str, Enum):
     """
 
     memgpt_agent = "memgpt_agent"
+    memgpt_v2_agent = "memgpt_v2_agent"
     split_thread_agent = "split_thread_agent"
     sleeptime_agent = "sleeptime_agent"
     voice_convo_agent = "voice_convo_agent"
@@ -298,31 +300,96 @@ class AgentStepState(BaseModel):
 
 
 def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
-    if agent_type == AgentType.sleeptime_agent:
+
+    # Sleeptime agents use the MemGPT v2 memory tools (line numbers)
+    # MemGPT v2 tools use line-number, so core memory blocks should have line numbers
+    if agent_type == AgentType.sleeptime_agent or agent_type == AgentType.memgpt_v2_agent:
         return (
+            "<memory_blocks>\nThe following memory blocks are currently engaged in your core memory unit:\n\n"
             "{% for block in blocks %}"
-            '<{{ block.label }} characters="{{ block.value|length }}/{{ block.limit }}">\n'
-            f"{CORE_MEMORY_LINE_NUMBER_WARNING}"
+            "<{{ block.label }}>\n"
+            "<description>\n"
+            "{{ block.description }}\n"
+            "</description>\n"
+            "<metadata>"
+            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
+            "- chars_current={{ block.value|length }}\n"
+            "- chars_limit={{ block.limit }}\n"
+            "</metadata>\n"
+            "<value>\n"
+            f"{CORE_MEMORY_LINE_NUMBER_WARNING}\n"
+            "{% for line in block.value.split('\\n') %}"
+            "Line {{ loop.index }}: {{ line }}\n"
+            "{% endfor %}"
+            "</value>\n"
+            "</{{ block.label }}>\n"
+            "{% if not loop.last %}\n{% endif %}"
+            "{% endfor %}"
+            "\n</memory_blocks>"
+            "<files>\nThe following memory files are currently accessible:\n\n"
+            "{% for block in file_blocks %}"
+            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
+            "<{{ block.label }}>\n"
+            "<description>\n"
+            "{{ block.description }}\n"
+            "</description>\n"
+            "<metadata>"
+            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
+            "- chars_current={{ block.value|length }}\n"
+            "- chars_limit={{ block.limit }}\n"
+            "</metadata>\n"
+            "<value>\n"
+            f"{CORE_MEMORY_LINE_NUMBER_WARNING}\n"
             "{% for line in block.value.split('\\n') %}"
             "Line {{ loop.index }}: {{ line }}\n"
             "{% endfor %}"
-            "</{{ block.label }}>"
+            "</value>\n"
+            "</{{ block.label }}>\n"
+            "</file>\n"
             "{% if not loop.last %}\n{% endif %}"
             "{% endfor %}"
+            "\n</files>"
+        )
+
+    # Default setup (MemGPT), no line numbers
+    else:
+        return (
+            "<memory_blocks>\nThe following memory blocks are currently engaged in your core memory unit:\n\n"
+            "{% for block in blocks %}"
+            "<{{ block.label }}>\n"
+            "<description>\n"
+            "{{ block.description }}\n"
+            "</description>\n"
+            "<metadata>"
+            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
+            "- chars_current={{ block.value|length }}\n"
+            "- chars_limit={{ block.limit }}\n"
+            "</metadata>\n"
+            "<value>\n"
+            "{{ block.value }}\n"
+            "</value>\n"
+            "</{{ block.label }}>\n"
+            "{% if not loop.last %}\n{% endif %}"
+            "{% endfor %}"
+            "\n</memory_blocks>"
+            "<files>\nThe following memory files are currently accessible:\n\n"
+            "{% for block in file_blocks %}"
+            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
+            "<{{ block.label }}>\n"
+            "<description>\n"
+            "{{ block.description }}\n"
+            "</description>\n"
+            "<metadata>"
+            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
+            "- chars_current={{ block.value|length }}\n"
+            "- chars_limit={{ block.limit }}\n"
+            "</metadata>\n"
+            "<value>\n"
+            "{{ block.value }}\n"
+            "</value>\n"
+            "</{{ block.label }}>\n"
+            "</file>\n"
+            "{% if not loop.last %}\n{% endif %}"
+            "{% endfor %}"
+            "\n</files>"
         )
-    return (
-        "{% for block in blocks %}"
-        "<{{ block.label }}>\n"
-        "<description>\n"
-        "{{ block.description }}\n"
-        "</description>\n"
-        "<metadata>\n"
-        '{% if block.read_only %}read_only="true" {% endif %}chars_current="{{ block.value|length }}" chars_limit="{{ block.limit }}"\n'
-        "</metadata>\n"
-        "<value>\n"
-        "{{ block.value }}\n"
-        "</value>\n"
-        "</{{ block.label }}>\n"
-        "{% if not loop.last %}\n{% endif %}"
-        "{% endfor %}"
-    )

letta/schemas/block.py

@@ -3,7 +3,7 @@ from typing import Optional
 from pydantic import Field, model_validator
 from typing_extensions import Self
 
-from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
+from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT, DEFAULT_HUMAN_BLOCK_DESCRIPTION, DEFAULT_PERSONA_BLOCK_DESCRIPTION
 from letta.schemas.letta_base import LettaBase
 
 # block of the LLM context
@@ -21,6 +21,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
     # template data (optional)
     template_name: Optional[str] = Field(None, description="Name of the block if it is a template.", alias="name")
     is_template: bool = Field(False, description="Whether the block is a template (e.g. saved human/persona options).")
+    preserve_on_migration: Optional[bool] = Field(False, description="Preserve the block on template migration.")
 
     # context window label
     label: Optional[str] = Field(None, description="Label of the block (e.g. 'human', 'persona') in the context window.")
@@ -85,12 +86,17 @@ class Human(Block):
     """Human block of the LLM context"""
 
     label: str = "human"
+    description: Optional[str] = Field(DEFAULT_HUMAN_BLOCK_DESCRIPTION, description="Description of the block.")
 
 
 class Persona(Block):
     """Persona block of the LLM context"""
 
     label: str = "persona"
+    description: Optional[str] = Field(DEFAULT_PERSONA_BLOCK_DESCRIPTION, description="Description of the block.")
+
+
+DEFAULT_BLOCKS = [Human(value=""), Persona(value="")]
 
 
 class BlockUpdate(BaseBlock):

letta/schemas/file.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from enum import Enum
 from typing import Optional
 
 from pydantic import Field
@@ -6,6 +7,15 @@ from pydantic import Field
 from letta.schemas.letta_base import LettaBase
 
 
+class FileStatus(str, Enum):
+    """
+    Enum to represent the state of a file.
+    """
+
+    open = "open"
+    closed = "closed"
+
+
 class FileMetadataBase(LettaBase):
     """Base class for FileMetadata schemas"""
 
@@ -29,3 +39,50 @@ class FileMetadata(FileMetadataBase):
     created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The creation date of the file.")
     updated_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The update date of the file.")
     is_deleted: bool = Field(False, description="Whether this file is deleted or not.")
+
+
+class FileAgentBase(LettaBase):
+    """Base class for the FileMetadata-⇄-Agent association schemas"""
+
+    __id_prefix__ = "file_agent"
+
+
+class FileAgent(FileAgentBase):
+    """
+    A single FileMetadata ⇄ Agent association row.
+
+    Captures:
+    • whether the agent currently has the file “open”
+    • the excerpt (grepped section) in the context window
+    • the last time the agent accessed the file
+    """
+
+    id: str = Field(
+        ...,
+        description="The internal ID",
+    )
+    organization_id: Optional[str] = Field(
+        None,
+        description="Org ID this association belongs to (inherited from both agent and file).",
+    )
+    agent_id: str = Field(..., description="Unique identifier of the agent.")
+    file_id: str = Field(..., description="Unique identifier of the file.")
+    is_open: bool = Field(True, description="True if the agent currently has the file open.")
+    visible_content: Optional[str] = Field(
+        None,
+        description="Portion of the file the agent is focused on (may be large).",
+    )
+    last_accessed_at: Optional[datetime] = Field(
+        default_factory=datetime.utcnow,
+        description="UTC timestamp of the agent’s most recent access to this file.",
+    )
+
+    created_at: Optional[datetime] = Field(
+        default_factory=datetime.utcnow,
+        description="Row creation timestamp (UTC).",
+    )
+    updated_at: Optional[datetime] = Field(
+        default_factory=datetime.utcnow,
+        description="Row last-update timestamp (UTC).",
+    )
+    is_deleted: bool = Field(False, description="Soft-delete flag.")

letta/schemas/mcp.py

@@ -0,0 +1,74 @@
+from typing import Any, Dict, Optional, Union
+
+from pydantic import Field
+
+from letta.functions.mcp_client.types import MCPServerType, SSEServerConfig, StdioServerConfig
+from letta.schemas.letta_base import LettaBase
+
+
+class BaseMCPServer(LettaBase):
+    __id_prefix__ = "mcp_server"
+
+
+class MCPServer(BaseMCPServer):
+    id: str = BaseMCPServer.generate_id_field()
+    server_type: MCPServerType = MCPServerType.SSE
+    server_name: str = Field(..., description="The name of the server")
+
+    # sse config
+    server_url: Optional[str] = Field(None, description="The URL of the server (MCP SSE client will connect to this URL)")
+
+    # stdio config
+    stdio_config: Optional[StdioServerConfig] = Field(
+        None, description="The configuration for the server (MCP 'local' client will run this command)"
+    )
+
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the tool.")
+
+    # metadata fields
+    created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
+    last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
+    metadata_: Optional[Dict[str, Any]] = Field(default_factory=dict, description="A dictionary of additional metadata for the tool.")
+
+    # TODO: add tokens?
+
+    def to_config(self) -> Union[SSEServerConfig, StdioServerConfig]:
+        if self.server_type == MCPServerType.SSE:
+            return SSEServerConfig(
+                server_name=self.server_name,
+                server_url=self.server_url,
+            )
+        elif self.server_type == MCPServerType.STDIO:
+            return self.stdio_config
+
+
+class RegisterSSEMCPServer(LettaBase):
+    server_name: str = Field(..., description="The name of the server")
+    server_type: MCPServerType = MCPServerType.SSE
+    server_url: str = Field(..., description="The URL of the server (MCP SSE client will connect to this URL)")
+
+
+class RegisterStdioMCPServer(LettaBase):
+    server_name: str = Field(..., description="The name of the server")
+    server_type: MCPServerType = MCPServerType.STDIO
+    stdio_config: StdioServerConfig = Field(..., description="The configuration for the server (MCP 'local' client will run this command)")
+
+
+class UpdateSSEMCPServer(LettaBase):
+    """Update an SSE MCP server"""
+
+    server_name: Optional[str] = Field(None, description="The name of the server")
+    server_url: Optional[str] = Field(None, description="The URL of the server (MCP SSE client will connect to this URL)")
+
+
+class UpdateStdioMCPServer(LettaBase):
+    """Update a Stdio MCP server"""
+
+    server_name: Optional[str] = Field(None, description="The name of the server")
+    stdio_config: Optional[StdioServerConfig] = Field(
+        None, description="The configuration for the server (MCP 'local' client will run this command)"
+    )
+
+
+UpdateMCPServer = Union[UpdateSSEMCPServer, UpdateStdioMCPServer]
+RegisterMCPServer = Union[RegisterSSEMCPServer, RegisterStdioMCPServer]

letta/schemas/memory.py

@@ -65,6 +65,9 @@ class Memory(BaseModel, validate_assignment=True):
 
     # Memory.block contains the list of memory blocks in the core memory
     blocks: List[Block] = Field(..., description="Memory blocks contained in the agent's in-context memory")
+    file_blocks: List[Block] = Field(
+        default_factory=list, description="Blocks representing the agent's in-context memory of an attached file"
+    )
 
     # Memory.template is a Jinja2 template for compiling memory module into a prompt string.
     prompt_template: str = Field(
@@ -96,7 +99,7 @@ class Memory(BaseModel, validate_assignment=True):
             Template(prompt_template)
 
             # Validate compatibility with current memory structure
-            Template(prompt_template).render(blocks=self.blocks)
+            Template(prompt_template).render(blocks=self.blocks, file_blocks=self.file_blocks)
 
             # If we get here, the template is valid and compatible
             self.prompt_template = prompt_template
@@ -108,7 +111,7 @@ class Memory(BaseModel, validate_assignment=True):
     def compile(self) -> str:
         """Generate a string representation of the memory in-context using the Jinja2 template"""
         template = Template(self.prompt_template)
-        return template.render(blocks=self.blocks)
+        return template.render(blocks=self.blocks, file_blocks=self.file_blocks)
 
     def list_block_labels(self) -> List[str]:
         """Return a list of the block names held inside the memory object"""

letta/schemas/message.py

@@ -36,6 +36,7 @@ from letta.schemas.letta_message_content import (
     ReasoningContent,
     RedactedReasoningContent,
     TextContent,
+    ToolReturnContent,
     get_letta_message_content_union_str_json_schema,
 )
 from letta.system import unpack_message
@@ -382,6 +383,7 @@ class Message(BaseMessage):
 
             try:
                 function_return = parse_json(text_content)
+                text_content = str(function_return.get("message", text_content))
                 status = function_return["status"]
                 if status == "OK":
                     status_enum = "success"
@@ -654,6 +656,8 @@ class Message(BaseMessage):
         parse_content_parts = False
         if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
             text_content = self.content[0].text
+        elif self.content and len(self.content) == 1 and isinstance(self.content[0], ToolReturnContent):
+            text_content = self.content[0].content
         # Otherwise, check if we have TextContent and multiple other parts
         elif self.content and len(self.content) > 1:
             text = [content for content in self.content if isinstance(content, TextContent)]
@@ -866,6 +870,8 @@ class Message(BaseMessage):
         #     role: str ('user' or 'model')
         if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
             text_content = self.content[0].text
+        elif self.content and len(self.content) == 1 and isinstance(self.content[0], ToolReturnContent):
+            text_content = self.content[0].content
         else:
             text_content = None
 
@@ -1000,6 +1006,8 @@ class Message(BaseMessage):
         # embedded function calls in multi-turn conversation become more clear
         if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
             text_content = self.content[0].text
+        if self.content and len(self.content) == 1 and isinstance(self.content[0], ToolReturnContent):
+            text_content = self.content[0].content
         else:
             text_content = None
         if self.role == "system":
@@ -1101,3 +1109,4 @@ class ToolReturn(BaseModel):
     status: Literal["success", "error"] = Field(..., description="The status of the tool call")
     stdout: Optional[List[str]] = Field(None, description="Captured stdout (e.g. prints, logs) from the tool invocation")
     stderr: Optional[List[str]] = Field(None, description="Captured stderr from the tool invocation")
+    # func_return: Optional[Any] = Field(None, description="The function return object")

letta/schemas/openai/openai.py

@@ -47,12 +47,6 @@ class OpenAIMessage(BaseModel):
     metadata: Optional[Dict] = Field(None, description="Metadata associated with the message.")
 
 
-class MessageFile(BaseModel):
-    id: str
-    object: str = "thread.message.file"
-    created_at: int  # unix timestamp
-
-
 class OpenAIThread(BaseModel):
     """Represents an OpenAI thread (equivalent to Letta agent)"""
 

letta/schemas/providers.py

@@ -86,7 +86,7 @@ class Provider(ProviderBase):
         return f"{base_name}/{model_name}"
 
     def cast_to_subtype(self):
-        match (self.provider_type):
+        match self.provider_type:
             case ProviderType.letta:
                 return LettaProvider(**self.model_dump(exclude_none=True))
             case ProviderType.openai:
@@ -869,6 +869,38 @@ class OllamaProvider(OpenAIProvider):
         ..., description="Default prompt formatter (aka model wrapper) to use on a /completions style API."
     )
 
+    async def list_llm_models_async(self) -> List[LLMConfig]:
+        """Async version of list_llm_models below"""
+        endpoint = f"{self.base_url}/api/tags"
+
+        import aiohttp
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(endpoint) as response:
+                if response.status != 200:
+                    raise Exception(f"Failed to list Ollama models: {response.text}")
+                response_json = await response.json()
+
+        configs = []
+        for model in response_json["models"]:
+            context_window = self.get_model_context_window(model["name"])
+            if context_window is None:
+                print(f"Ollama model {model['name']} has no context window")
+                continue
+            configs.append(
+                LLMConfig(
+                    model=model["name"],
+                    model_endpoint_type="ollama",
+                    model_endpoint=self.base_url,
+                    model_wrapper=self.default_prompt_formatter,
+                    context_window=context_window,
+                    handle=self.get_handle(model["name"]),
+                    provider_name=self.name,
+                    provider_category=self.provider_category,
+                )
+            )
+        return configs
+
     def list_llm_models(self) -> List[LLMConfig]:
         # https://github.com/ollama/ollama/blob/main/docs/api.md#list-local-models
         import requests
@@ -1005,9 +1037,6 @@ class GroqProvider(OpenAIProvider):
     def list_embedding_models(self) -> List[EmbeddingConfig]:
         return []
 
-    def get_model_context_window_size(self, model_name: str):
-        raise NotImplementedError
-
 
 class TogetherProvider(OpenAIProvider):
     """TogetherAI provider that uses the /completions API

letta/schemas/tool.py

@@ -11,10 +11,9 @@ from letta.constants import (
     LETTA_VOICE_TOOL_MODULE_NAME,
     MCP_TOOL_TAG_NAME_PREFIX,
 )
-from letta.functions.ast_parsers import get_function_name_and_description
+from letta.functions.ast_parsers import get_function_name_and_docstring
 from letta.functions.composio_helpers import generate_composio_tool_wrapper
 from letta.functions.functions import derive_openai_json_schema, get_json_schema_from_module
-from letta.functions.helpers import generate_langchain_tool_wrapper, generate_mcp_tool_wrapper, generate_model_from_args_json_schema
 from letta.functions.mcp_client.types import MCPTool
 from letta.functions.schema_generator import (
     generate_schema_from_args_schema_v2,
@@ -71,31 +70,30 @@ class Tool(BaseTool):
         """
         Refresh name, description, source_code, and json_schema.
         """
-        if self.tool_type == ToolType.CUSTOM:
-            # If it's a custom tool, we need to ensure source_code is present
+        from letta.functions.helpers import generate_model_from_args_json_schema
+
+        if self.tool_type is ToolType.CUSTOM:
             if not self.source_code:
                 error_msg = f"Custom tool with id={self.id} is missing source_code field."
                 logger.error(error_msg)
                 raise ValueError(error_msg)
 
             # Always derive json_schema for freshest possible json_schema
-            # TODO: Instead of checking the tag, we should having `COMPOSIO` as a specific ToolType
-            # TODO: We skip this for Composio bc composio json schemas are derived differently
-            if not (COMPOSIO_TOOL_TAG_NAME in self.tags):
-                if self.args_json_schema is not None:
-                    name, description = get_function_name_and_description(self.source_code, self.name)
-                    args_schema = generate_model_from_args_json_schema(self.args_json_schema)
-                    self.json_schema = generate_schema_from_args_schema_v2(
-                        args_schema=args_schema,
-                        name=name,
-                        description=description,
-                    )
-                else:
-                    try:
-                        self.json_schema = derive_openai_json_schema(source_code=self.source_code)
-                    except Exception as e:
-                        error_msg = f"Failed to derive json schema for tool with id={self.id} name={self.name}. Error: {str(e)}"
-                        logger.error(error_msg)
+            if self.args_json_schema is not None:
+                name, description = get_function_name_and_docstring(self.source_code, self.name)
+                args_schema = generate_model_from_args_json_schema(self.args_json_schema)
+                self.json_schema = generate_schema_from_args_schema_v2(
+                    args_schema=args_schema,
+                    name=name,
+                    description=description,
+                    append_heartbeat=False,
+                )
+            else:
+                try:
+                    self.json_schema = derive_openai_json_schema(source_code=self.source_code)
+                except Exception as e:
+                    error_msg = f"Failed to derive json schema for tool with id={self.id} name={self.name}. Error: {str(e)}"
+                    logger.error(error_msg)
         elif self.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE, ToolType.LETTA_SLEEPTIME_CORE}:
             # If it's letta core tool, we generate the json_schema on the fly here
             self.json_schema = get_json_schema_from_module(module_name=LETTA_CORE_TOOL_MODULE_NAME, function_name=self.name)
@@ -108,6 +106,9 @@ class Tool(BaseTool):
         elif self.tool_type in {ToolType.LETTA_BUILTIN}:
             # If it's letta voice tool, we generate the json_schema on the fly here
             self.json_schema = get_json_schema_from_module(module_name=LETTA_BUILTIN_TOOL_MODULE_NAME, function_name=self.name)
+        elif self.tool_type in {ToolType.EXTERNAL_COMPOSIO}:
+            # Composio schemas handled separately
+            pass
 
         # At this point, we need to validate that at least json_schema is populated
         if not self.json_schema:
@@ -146,6 +147,8 @@ class ToolCreate(LettaBase):
 
     @classmethod
     def from_mcp(cls, mcp_server_name: str, mcp_tool: MCPTool) -> "ToolCreate":
+        from letta.functions.helpers import generate_mcp_tool_wrapper
+
         # Pass the MCP tool to the schema generator
         json_schema = generate_tool_schema_for_mcp(mcp_tool=mcp_tool)
 
@@ -218,6 +221,8 @@ class ToolCreate(LettaBase):
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the provided LangChain BaseTool object.
         """
+        from letta.functions.helpers import generate_langchain_tool_wrapper
+
         description = langchain_tool.description
         source_type = "python"
         tags = ["langchain"]