letta-nightly 0.6.41.dev20250317104157__tar.gz → 0.6.43.dev20250318012126__tar.gz

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.41.dev20250317104157
+Version: 0.6.43.dev20250318012126
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -31,7 +31,7 @@ Requires-Dist: brotli (>=1.1.0,<2.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: composio-core (>=0.7.7,<0.8.0)
 Requires-Dist: composio-langchain (>=0.7.7,<0.8.0)
-Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0) ; extra == "desktop" or extra == "all"
+Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0)
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
 Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: docstring-parser (>=0.16,<0.17)

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.41"
+__version__ = "0.6.43"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/agent.py

@@ -367,7 +367,10 @@ class Agent(BaseAgent):
     ) -> ChatCompletionResponse:
         """Get response from LLM API with robust retry mechanism."""
         log_telemetry(self.logger, "_get_ai_reply start")
-        allowed_tool_names = self.tool_rules_solver.get_allowed_tool_names(last_function_response=self.last_function_response)
+        available_tools = set([t.name for t in self.agent_state.tools])
+        allowed_tool_names = self.tool_rules_solver.get_allowed_tool_names(
+            available_tools=available_tools, last_function_response=self.last_function_response
+        )
         agent_state_tool_jsons = [t.json_schema for t in self.agent_state.tools]
 
         allowed_functions = (
@@ -377,8 +380,8 @@ class Agent(BaseAgent):
         )
 
         # Don't allow a tool to be called if it failed last time
-        if last_function_failed and self.tool_rules_solver.last_tool_name:
-            allowed_functions = [f for f in allowed_functions if f["name"] != self.tool_rules_solver.last_tool_name]
+        if last_function_failed and self.tool_rules_solver.tool_call_history:
+            allowed_functions = [f for f in allowed_functions if f["name"] != self.tool_rules_solver.tool_call_history[-1]]
             if not allowed_functions:
                 return None
 
@@ -773,6 +776,11 @@ class Agent(BaseAgent):
         **kwargs,
     ) -> LettaUsageStatistics:
         """Run Agent.step in a loop, handling chaining via heartbeat requests and function failures"""
+        # Defensively clear the tool rules solver history
+        # Usually this would be extraneous as Agent loop is re-loaded on every message send
+        # But just to be safe
+        self.tool_rules_solver.clear_tool_history()
+
         next_input_message = messages if isinstance(messages, list) else [messages]
         counter = 0
         total_usage = UsageStatistics()

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/embeddings.py

@@ -3,6 +3,7 @@ from typing import Any, List, Optional
 
 import numpy as np
 import tiktoken
+from openai import OpenAI
 
 from letta.constants import EMBEDDING_TO_TOKENIZER_DEFAULT, EMBEDDING_TO_TOKENIZER_MAP, MAX_EMBEDDING_DIM
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -201,6 +202,21 @@ class GoogleVertexEmbeddings:
         return response.embeddings[0].embedding
 
 
+class OpenAIEmbeddings:
+
+    def __init__(self, api_key: str, model: str, base_url: str):
+        if base_url:
+            self.client = OpenAI(api_key=api_key, base_url=base_url)
+        else:
+            self.client = OpenAI(api_key=api_key)
+        self.model = model
+
+    def get_text_embedding(self, text: str):
+        response = self.client.embeddings.create(input=text, model=self.model)
+
+        return response.data[0].embedding
+
+
 def query_embedding(embedding_model, query_text: str):
     """Generate padded embedding for querying database"""
     query_vec = embedding_model.get_text_embedding(query_text)
@@ -218,15 +234,9 @@ def embedding_model(config: EmbeddingConfig, user_id: Optional[uuid.UUID] = None
     from letta.settings import model_settings
 
     if endpoint_type == "openai":
-        from llama_index.embeddings.openai import OpenAIEmbedding
-
-        additional_kwargs = {"user_id": user_id} if user_id else {}
-        model = OpenAIEmbedding(
-            api_base=config.embedding_endpoint,
-            api_key=model_settings.openai_api_key,
-            additional_kwargs=additional_kwargs,
+        return OpenAIEmbeddings(
+            api_key=model_settings.openai_api_key, model=config.embedding_model, base_url=model_settings.openai_api_base
         )
-        return model
 
     elif endpoint_type == "azure":
         assert all(

letta_nightly-0.6.43.dev20250318012126/letta/functions/mcp_client/base_client.py

@@ -0,0 +1,87 @@
+import asyncio
+from typing import List, Optional, Tuple
+
+from mcp import ClientSession, Tool
+
+from letta.functions.mcp_client.types import BaseServerConfig
+from letta.log import get_logger
+from letta.settings import tool_settings
+
+logger = get_logger(__name__)
+
+
+class BaseMCPClient:
+    def __init__(self, server_config: BaseServerConfig):
+        self.server_config = server_config
+        self.session: Optional[ClientSession] = None
+        self.stdio = None
+        self.write = None
+        self.initialized = False
+        self.loop = asyncio.new_event_loop()
+        self.cleanup_funcs = []
+
+    def connect_to_server(self):
+        asyncio.set_event_loop(self.loop)
+        success = self._initialize_connection(self.server_config, timeout=tool_settings.mcp_connect_to_server_timeout)
+
+        if success:
+            try:
+                self.loop.run_until_complete(
+                    asyncio.wait_for(self.session.initialize(), timeout=tool_settings.mcp_connect_to_server_timeout)
+                )
+                self.initialized = True
+            except asyncio.TimeoutError:
+                raise RuntimeError(
+                    f"Timed out while initializing session for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_connect_to_server_timeout}s)."
+                )
+        else:
+            raise RuntimeError(
+                f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
+            )
+
+    def _initialize_connection(self, server_config: BaseServerConfig, timeout: float) -> bool:
+        raise NotImplementedError("Subclasses must implement _initialize_connection")
+
+    def list_tools(self) -> List[Tool]:
+        self._check_initialized()
+        try:
+            response = self.loop.run_until_complete(
+                asyncio.wait_for(self.session.list_tools(), timeout=tool_settings.mcp_list_tools_timeout)
+            )
+            return response.tools
+        except asyncio.TimeoutError:
+            # Could log, throw a custom exception, etc.
+            logger.error(
+                f"Timed out while listing tools for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_list_tools_timeout}s)."
+            )
+            return []
+
+    def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
+        self._check_initialized()
+        try:
+            result = self.loop.run_until_complete(
+                asyncio.wait_for(self.session.call_tool(tool_name, tool_args), timeout=tool_settings.mcp_execute_tool_timeout)
+            )
+            return str(result.content), result.isError
+        except asyncio.TimeoutError:
+            logger.error(
+                f"Timed out while executing tool '{tool_name}' for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_execute_tool_timeout}s)."
+            )
+            return "", True
+
+    def _check_initialized(self):
+        if not self.initialized:
+            logger.error("MCPClient has not been initialized")
+            raise RuntimeError("MCPClient has not been initialized")
+
+    def cleanup(self):
+        try:
+            for cleanup_func in self.cleanup_funcs:
+                cleanup_func()
+            self.initialized = False
+            if not self.loop.is_closed():
+                self.loop.close()
+        except Exception as e:
+            logger.warning(e)
+        finally:
+            logger.info("Cleaned up MCP clients on shutdown.")

letta_nightly-0.6.43.dev20250318012126/letta/functions/mcp_client/sse_client.py

@@ -0,0 +1,33 @@
+import asyncio
+
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+from letta.functions.mcp_client.base_client import BaseMCPClient
+from letta.functions.mcp_client.types import SSEServerConfig
+from letta.log import get_logger
+
+# see: https://modelcontextprotocol.io/quickstart/user
+MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
+
+logger = get_logger(__name__)
+
+
+class SSEMCPClient(BaseMCPClient):
+    def _initialize_connection(self, server_config: SSEServerConfig, timeout: float) -> bool:
+        try:
+            sse_cm = sse_client(url=server_config.server_url)
+            sse_transport = self.loop.run_until_complete(asyncio.wait_for(sse_cm.__aenter__(), timeout=timeout))
+            self.stdio, self.write = sse_transport
+            self.cleanup_funcs.append(lambda: self.loop.run_until_complete(sse_cm.__aexit__(None, None, None)))
+
+            session_cm = ClientSession(self.stdio, self.write)
+            self.session = self.loop.run_until_complete(asyncio.wait_for(session_cm.__aenter__(), timeout=timeout))
+            self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
+            return True
+        except asyncio.TimeoutError:
+            logger.error(f"Timed out while establishing SSE connection (timeout={timeout}s).")
+            return False
+        except Exception:
+            logger.exception("Exception occurred while initializing SSE client session.")
+            return False

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/functions/mcp_client/stdio_client.py

@@ -1,3 +1,4 @@
+import asyncio
 import sys
 from contextlib import asynccontextmanager
 
@@ -16,19 +17,23 @@ logger = get_logger(__name__)
 
 
 class StdioMCPClient(BaseMCPClient):
-    def _initialize_connection(self, server_config: StdioServerConfig) -> bool:
+    def _initialize_connection(self, server_config: StdioServerConfig, timeout: float) -> bool:
         try:
             server_params = StdioServerParameters(command=server_config.command, args=server_config.args)
             stdio_cm = forked_stdio_client(server_params)
-            stdio_transport = self.loop.run_until_complete(stdio_cm.__aenter__())
+            stdio_transport = self.loop.run_until_complete(asyncio.wait_for(stdio_cm.__aenter__(), timeout=timeout))
             self.stdio, self.write = stdio_transport
             self.cleanup_funcs.append(lambda: self.loop.run_until_complete(stdio_cm.__aexit__(None, None, None)))
 
             session_cm = ClientSession(self.stdio, self.write)
-            self.session = self.loop.run_until_complete(session_cm.__aenter__())
+            self.session = self.loop.run_until_complete(asyncio.wait_for(session_cm.__aenter__(), timeout=timeout))
             self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
             return True
+        except asyncio.TimeoutError:
+            logger.error(f"Timed out while establishing stdio connection (timeout={timeout}s).")
+            return False
         except Exception:
+            logger.exception("Exception occurred while initializing stdio client session.")
             return False
 
 

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/helpers/converters.py

@@ -20,7 +20,15 @@ from letta.schemas.letta_message_content import (
 )
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import ToolReturn
-from letta.schemas.tool_rule import ChildToolRule, ConditionalToolRule, ContinueToolRule, InitToolRule, TerminalToolRule, ToolRule
+from letta.schemas.tool_rule import (
+    ChildToolRule,
+    ConditionalToolRule,
+    ContinueToolRule,
+    InitToolRule,
+    MaxCountPerStepToolRule,
+    TerminalToolRule,
+    ToolRule,
+)
 
 # --------------------------
 # LLMConfig Serialization
@@ -85,23 +93,27 @@ def deserialize_tool_rules(data: Optional[List[Dict]]) -> List[Union[ChildToolRu
     return [deserialize_tool_rule(rule_data) for rule_data in data]
 
 
-def deserialize_tool_rule(data: Dict) -> Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule]:
+def deserialize_tool_rule(
+    data: Dict,
+) -> Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule, MaxCountPerStepToolRule]:
     """Deserialize a dictionary to the appropriate ToolRule subclass based on 'type'."""
     rule_type = ToolRuleType(data.get("type"))
 
-    if rule_type == ToolRuleType.run_first or rule_type == ToolRuleType.InitToolRule:
+    if rule_type == ToolRuleType.run_first:
         data["type"] = ToolRuleType.run_first
         return InitToolRule(**data)
-    elif rule_type == ToolRuleType.exit_loop or rule_type == ToolRuleType.TerminalToolRule:
+    elif rule_type == ToolRuleType.exit_loop:
         data["type"] = ToolRuleType.exit_loop
         return TerminalToolRule(**data)
-    elif rule_type == ToolRuleType.constrain_child_tools or rule_type == ToolRuleType.ToolRule:
+    elif rule_type == ToolRuleType.constrain_child_tools:
         data["type"] = ToolRuleType.constrain_child_tools
         return ChildToolRule(**data)
     elif rule_type == ToolRuleType.conditional:
         return ConditionalToolRule(**data)
     elif rule_type == ToolRuleType.continue_loop:
         return ContinueToolRule(**data)
+    elif rule_type == ToolRuleType.max_count_per_step:
+        return MaxCountPerStepToolRule(**data)
     raise ValueError(f"Unknown ToolRule type: {rule_type}")
 
 

letta_nightly-0.6.43.dev20250318012126/letta/helpers/tool_rule_solver.py

@@ -0,0 +1,129 @@
+from typing import List, Optional, Set, Union
+
+from pydantic import BaseModel, Field
+
+from letta.schemas.enums import ToolRuleType
+from letta.schemas.tool_rule import (
+    BaseToolRule,
+    ChildToolRule,
+    ConditionalToolRule,
+    ContinueToolRule,
+    InitToolRule,
+    MaxCountPerStepToolRule,
+    TerminalToolRule,
+)
+
+
+class ToolRuleValidationError(Exception):
+    """Custom exception for tool rule validation errors in ToolRulesSolver."""
+
+    def __init__(self, message: str):
+        super().__init__(f"ToolRuleValidationError: {message}")
+
+
+class ToolRulesSolver(BaseModel):
+    init_tool_rules: List[InitToolRule] = Field(
+        default_factory=list, description="Initial tool rules to be used at the start of tool execution."
+    )
+    continue_tool_rules: List[ContinueToolRule] = Field(
+        default_factory=list, description="Continue tool rules to be used to continue tool execution."
+    )
+    # TODO: This should be renamed?
+    # TODO: These are tools that control the set of allowed functions in the next turn
+    child_based_tool_rules: List[Union[ChildToolRule, ConditionalToolRule, MaxCountPerStepToolRule]] = Field(
+        default_factory=list, description="Standard tool rules for controlling execution sequence and allowed transitions."
+    )
+    terminal_tool_rules: List[TerminalToolRule] = Field(
+        default_factory=list, description="Terminal tool rules that end the agent loop if called."
+    )
+    tool_call_history: List[str] = Field(default_factory=list, description="History of tool calls, updated with each tool call.")
+
+    def __init__(self, tool_rules: List[BaseToolRule], **kwargs):
+        super().__init__(**kwargs)
+        # Separate the provided tool rules into init, standard, and terminal categories
+        for rule in tool_rules:
+            if rule.type == ToolRuleType.run_first:
+                assert isinstance(rule, InitToolRule)
+                self.init_tool_rules.append(rule)
+            elif rule.type == ToolRuleType.constrain_child_tools:
+                assert isinstance(rule, ChildToolRule)
+                self.child_based_tool_rules.append(rule)
+            elif rule.type == ToolRuleType.conditional:
+                assert isinstance(rule, ConditionalToolRule)
+                self.validate_conditional_tool(rule)
+                self.child_based_tool_rules.append(rule)
+            elif rule.type == ToolRuleType.exit_loop:
+                assert isinstance(rule, TerminalToolRule)
+                self.terminal_tool_rules.append(rule)
+            elif rule.type == ToolRuleType.continue_loop:
+                assert isinstance(rule, ContinueToolRule)
+                self.continue_tool_rules.append(rule)
+            elif rule.type == ToolRuleType.max_count_per_step:
+                assert isinstance(rule, MaxCountPerStepToolRule)
+                self.child_based_tool_rules.append(rule)
+
+    def update_tool_usage(self, tool_name: str):
+        """Update the internal state to track tool call history."""
+        self.tool_call_history.append(tool_name)
+
+    def clear_tool_history(self):
+        """Clear the history of tool calls."""
+        self.tool_call_history.clear()
+
+    def get_allowed_tool_names(
+        self, available_tools: Set[str], error_on_empty: bool = False, last_function_response: Optional[str] = None
+    ) -> List[str]:
+        """Get a list of tool names allowed based on the last tool called."""
+        # TODO: This piece of code here is quite ugly and deserves a refactor
+        # TODO: There's some weird logic encoded here:
+        # TODO: -> This only takes into consideration Init, and a set of Child/Conditional/MaxSteps tool rules
+        # TODO: -> Init tool rules outputs are treated additively, Child/Conditional/MaxSteps are intersection based
+        # TODO: -> Tool rules should probably be refactored to take in a set of tool names?
+        # If no tool has been called yet, return InitToolRules additively
+        if not self.tool_call_history:
+            if self.init_tool_rules:
+                # If there are init tool rules, only return those defined in the init tool rules
+                return [rule.tool_name for rule in self.init_tool_rules]
+            else:
+                # Otherwise, return all the available tools
+                return list(available_tools)
+        else:
+            # Collect valid tools from all child-based rules
+            valid_tool_sets = [
+                rule.get_valid_tools(self.tool_call_history, available_tools, last_function_response)
+                for rule in self.child_based_tool_rules
+            ]
+
+            # Compute intersection of all valid tool sets
+            final_allowed_tools = set.intersection(*valid_tool_sets) if valid_tool_sets else available_tools
+
+            if error_on_empty and not final_allowed_tools:
+                raise ValueError("No valid tools found based on tool rules.")
+
+            return list(final_allowed_tools)
+
+    def is_terminal_tool(self, tool_name: str) -> bool:
+        """Check if the tool is defined as a terminal tool in the terminal tool rules."""
+        return any(rule.tool_name == tool_name for rule in self.terminal_tool_rules)
+
+    def has_children_tools(self, tool_name):
+        """Check if the tool has children tools"""
+        return any(rule.tool_name == tool_name for rule in self.child_based_tool_rules)
+
+    def is_continue_tool(self, tool_name):
+        """Check if the tool is defined as a continue tool in the tool rules."""
+        return any(rule.tool_name == tool_name for rule in self.continue_tool_rules)
+
+    def validate_conditional_tool(self, rule: ConditionalToolRule):
+        """
+        Validate a conditional tool rule
+
+        Args:
+            rule (ConditionalToolRule): The conditional tool rule to validate
+
+        Raises:
+            ToolRuleValidationError: If the rule is invalid
+        """
+        if len(rule.child_output_mapping) == 0:
+            raise ToolRuleValidationError("Conditional tool rule must have at least one child tool.")
+        return True

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/llm_api/anthropic.py

@@ -840,7 +840,7 @@ def anthropic_chat_completions_process_stream(
     # Create a dummy message for ID/datetime if needed
     dummy_message = _Message(
         role=_MessageRole.assistant,
-        text="",
+        content=[],
         agent_id="",
         model="",
         name=None,

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/memory.py

@@ -37,7 +37,12 @@ def get_memory_functions(cls: Memory) -> Dict[str, Callable]:
 
 def _format_summary_history(message_history: List[Message]):
     # TODO use existing prompt formatters for this (eg ChatML)
-    return "\n".join([f"{m.role}: {m.content[0].text}" for m in message_history])
+    def get_message_text(content):
+        if content and len(content) == 1 and isinstance(content[0], TextContent):
+            return content[0].text
+        return ""
+
+    return "\n".join([f"{m.role}: {get_message_text(m.content)}" for m in message_history])
 
 
 def summarize_messages(

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/orm/sqlalchemy_base.py

@@ -508,10 +508,13 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         raise NotImplementedError("Sqlalchemy models must declare a __pydantic_model__ property to be convertable.")
 
     def to_pydantic(self) -> "BaseModel":
-        """converts to the basic pydantic model counterpart"""
-        model = self.__pydantic_model__.model_validate(self)
-        if hasattr(self, "metadata_"):
-            model.metadata = self.metadata_
+        """Converts the SQLAlchemy model to its corresponding Pydantic model."""
+        model = self.__pydantic_model__.model_validate(self, from_attributes=True)
+
+        # Explicitly map metadata_ to metadata in Pydantic model
+        if hasattr(self, "metadata_") and hasattr(model, "metadata_"):
+            setattr(model, "metadata_", self.metadata_)  # Ensures correct assignment
+
         return model
 
     def pretty_print_columns(self) -> str:

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/orm/tool.py

@@ -44,5 +44,6 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     source_code: Mapped[Optional[str]] = mapped_column(String, doc="The source code of the function.")
     json_schema: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The OAI compatable JSON schema of the function.")
     args_json_schema: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The JSON schema of the function arguments.")
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="A dictionary of additional metadata for the tool.")
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/schemas/enums.py

@@ -47,8 +47,4 @@ class ToolRuleType(str, Enum):
     continue_loop = "continue_loop"
     conditional = "conditional"
     constrain_child_tools = "constrain_child_tools"
-    require_parent_tools = "require_parent_tools"
-    # Deprecated
-    InitToolRule = "InitToolRule"
-    TerminalToolRule = "TerminalToolRule"
-    ToolRule = "ToolRule"
+    max_count_per_step = "max_count_per_step"

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/schemas/message.py

@@ -748,6 +748,12 @@ class Message(BaseMessage):
         else:
             raise ValueError(self.role)
 
+        # Validate that parts is never empty before returning
+        if "parts" not in google_ai_message or not google_ai_message["parts"]:
+            # If parts is empty, add a default text part
+            google_ai_message["parts"] = [{"text": "empty message"}]
+            warnings.warn(f"Empty 'parts' detected in message with role '{self.role}'. Added default empty text part.")
+
         return google_ai_message
 
     def to_cohere_dict(

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/schemas/source.py

@@ -50,7 +50,12 @@ class SourceCreate(BaseSource):
     # required
     name: str = Field(..., description="The name of the source.")
     # TODO: @matt, make this required after shub makes the FE changes
-    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the source.")
+
+    embedding: Optional[str] = Field(None, description="The hande for the embedding config used by the source.")
+    embedding_chunk_size: Optional[int] = Field(None, description="The chunk size of the embedding.")
+
+    # TODO: remove (legacy config)
+    embedding_config: Optional[EmbeddingConfig] = Field(None, description="(Legacy) The embedding configuration used by the source.")
 
     # optional
     description: Optional[str] = Field(None, description="The description of the source.")

{letta_nightly-0.6.41.dev20250317104157 → letta_nightly-0.6.43.dev20250318012126}/letta/schemas/tool.py

@@ -66,6 +66,7 @@ class Tool(BaseTool):
     # 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.")
 
     @model_validator(mode="after")
     def refresh_source_code_and_json_schema(self):
@@ -137,10 +138,6 @@ class ToolCreate(LettaBase):
 
     @classmethod
     def from_mcp(cls, mcp_server_name: str, mcp_tool: MCPTool) -> "ToolCreate":
-
-        # Get the MCP tool from the MCP server
-        # NVM
-
         # Pass the MCP tool to the schema generator
         json_schema = generate_tool_schema_for_mcp(mcp_tool=mcp_tool)