letta-nightly 0.6.34.dev20250303104329__py3-none-any.whl → 0.6.34.dev20250303230404__py3-none-any.whl

letta/functions/helpers.py

@@ -1,11 +1,11 @@
 import asyncio
 import threading
 from random import uniform
-from typing import Any, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
 import humps
 from composio.constants import DEFAULT_ENTITY_ID
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, create_model
 
 from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.functions.interface import MultiAgentMessagingInterface
@@ -561,3 +561,80 @@ async def _send_message_to_agents_matching_all_tags_async(sender_agent: "Agent",
 
     log_telemetry(sender_agent.logger, "_send_message_to_agents_matching_all_tags_async finish", message=message, tags=tags)
     return final
+
+
+def generate_model_from_args_json_schema(schema: Dict[str, Any]) -> Type[BaseModel]:
+    """Creates a Pydantic model from a JSON schema.
+
+    Args:
+        schema: The JSON schema dictionary
+
+    Returns:
+        A Pydantic model class
+    """
+    # First create any nested models from $defs in reverse order to handle dependencies
+    nested_models = {}
+    if "$defs" in schema:
+        for name, model_schema in reversed(list(schema.get("$defs", {}).items())):
+            nested_models[name] = _create_model_from_schema(name, model_schema, nested_models)
+
+    # Create and return the main model
+    return _create_model_from_schema(schema.get("title", "DynamicModel"), schema, nested_models)
+
+
+def _create_model_from_schema(name: str, model_schema: Dict[str, Any], nested_models: Dict[str, Type[BaseModel]] = None) -> Type[BaseModel]:
+    fields = {}
+    for field_name, field_schema in model_schema["properties"].items():
+        field_type = _get_field_type(field_schema, nested_models)
+        required = field_name in model_schema.get("required", [])
+        description = field_schema.get("description", "")  # Get description or empty string
+        fields[field_name] = (field_type, Field(..., description=description) if required else Field(None, description=description))
+
+    return create_model(name, **fields)
+
+
+def _get_field_type(field_schema: Dict[str, Any], nested_models: Dict[str, Type[BaseModel]] = None) -> Any:
+    """Helper to convert JSON schema types to Python types."""
+    if field_schema.get("type") == "string":
+        return str
+    elif field_schema.get("type") == "integer":
+        return int
+    elif field_schema.get("type") == "number":
+        return float
+    elif field_schema.get("type") == "boolean":
+        return bool
+    elif field_schema.get("type") == "array":
+        item_type = field_schema["items"].get("$ref", "").split("/")[-1]
+        if item_type and nested_models and item_type in nested_models:
+            return List[nested_models[item_type]]
+        return List[_get_field_type(field_schema["items"], nested_models)]
+    elif field_schema.get("type") == "object":
+        if "$ref" in field_schema:
+            ref_type = field_schema["$ref"].split("/")[-1]
+            if nested_models and ref_type in nested_models:
+                return nested_models[ref_type]
+        elif "additionalProperties" in field_schema:
+            value_type = _get_field_type(field_schema["additionalProperties"], nested_models)
+            return Dict[str, value_type]
+        return dict
+    elif field_schema.get("$ref") is not None:
+        ref_type = field_schema["$ref"].split("/")[-1]
+        if nested_models and ref_type in nested_models:
+            return nested_models[ref_type]
+        else:
+            raise ValueError(f"Reference {ref_type} not found in nested models")
+    elif field_schema.get("anyOf") is not None:
+        types = []
+        has_null = False
+        for type_option in field_schema["anyOf"]:
+            if type_option.get("type") == "null":
+                has_null = True
+            else:
+                types.append(_get_field_type(type_option, nested_models))
+        # If we have exactly one type and null, make it Optional
+        if has_null and len(types) == 1:
+            return Optional[types[0]]
+        # Otherwise make it a Union of all types
+        else:
+            return Union[tuple(types)]
+    raise ValueError(f"Unable to convert pydantic field schema to type: {field_schema}")

letta/functions/schema_generator.py

@@ -235,6 +235,9 @@ def pydantic_model_to_json_schema(model: Type[BaseModel]) -> dict:
         if "description" not in prop:
             raise ValueError(f"Property {prop} lacks a 'description' key")
 
+        if "type" not in prop and "$ref" in prop:
+            prop["type"] = "object"
+
         # Handle the case where the property is a $ref to another model
         if "$ref" in prop:
             # Resolve the reference to the nested model

letta/helpers/converters.py

@@ -78,11 +78,11 @@ def deserialize_tool_rule(data: Dict) -> Union[ChildToolRule, InitToolRule, Term
     """Deserialize a dictionary to the appropriate ToolRule subclass based on 'type'."""
     rule_type = ToolRuleType(data.get("type"))
 
-    if rule_type == ToolRuleType.run_first:
+    if rule_type == ToolRuleType.run_first or rule_type == ToolRuleType.InitToolRule:
         return InitToolRule(**data)
-    elif rule_type == ToolRuleType.exit_loop:
+    elif rule_type == ToolRuleType.exit_loop or rule_type == ToolRuleType.TerminalToolRule:
         return TerminalToolRule(**data)
-    elif rule_type == ToolRuleType.constrain_child_tools:
+    elif rule_type == ToolRuleType.constrain_child_tools or rule_type == ToolRuleType.ToolRule:
         return ChildToolRule(**data)
     elif rule_type == ToolRuleType.conditional:
         return ConditionalToolRule(**data)

letta/interfaces/openai_chat_completions_streaming_interface.py

@@ -0,0 +1,109 @@
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+from openai import AsyncStream
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk, Choice, ChoiceDelta
+
+from letta.constants import PRE_EXECUTION_MESSAGE_ARG
+from letta.interfaces.utils import _format_sse_chunk
+from letta.server.rest_api.optimistic_json_parser import OptimisticJSONParser
+
+
+class OpenAIChatCompletionsStreamingInterface:
+    """
+    Encapsulates the logic for streaming responses from OpenAI.
+    This class handles parsing of partial tokens, pre-execution messages,
+    and detection of tool call events.
+    """
+
+    def __init__(self, stream_pre_execution_message: bool = True):
+        self.optimistic_json_parser: OptimisticJSONParser = OptimisticJSONParser()
+        self.stream_pre_execution_message: bool = stream_pre_execution_message
+
+        self.current_parsed_json_result: Dict[str, Any] = {}
+        self.content_buffer: List[str] = []
+        self.tool_call_happened: bool = False
+        self.finish_reason_stop: bool = False
+
+        self.tool_call_name: Optional[str] = None
+        self.tool_call_args_str: str = ""
+        self.tool_call_id: Optional[str] = None
+
+    async def process(self, stream: AsyncStream[ChatCompletionChunk]) -> AsyncGenerator[str, None]:
+        """
+        Iterates over the OpenAI stream, yielding SSE events.
+        It also collects tokens and detects if a tool call is triggered.
+        """
+        async with stream:
+            async for chunk in stream:
+                choice = chunk.choices[0]
+                delta = choice.delta
+                finish_reason = choice.finish_reason
+
+                async for sse_chunk in self._process_content(delta, chunk):
+                    yield sse_chunk
+
+                async for sse_chunk in self._process_tool_calls(delta, chunk):
+                    yield sse_chunk
+
+                if self._handle_finish_reason(finish_reason):
+                    break
+
+    async def _process_content(self, delta: ChoiceDelta, chunk: ChatCompletionChunk) -> AsyncGenerator[str, None]:
+        """Processes regular content tokens and streams them."""
+        if delta.content:
+            self.content_buffer.append(delta.content)
+            yield _format_sse_chunk(chunk)
+
+    async def _process_tool_calls(self, delta: ChoiceDelta, chunk: ChatCompletionChunk) -> AsyncGenerator[str, None]:
+        """Handles tool call initiation and streaming of pre-execution messages."""
+        if not delta.tool_calls:
+            return
+
+        tool_call = delta.tool_calls[0]
+        self._update_tool_call_info(tool_call)
+
+        if self.stream_pre_execution_message and tool_call.function.arguments:
+            self.tool_call_args_str += tool_call.function.arguments
+            async for sse_chunk in self._stream_pre_execution_message(chunk, tool_call):
+                yield sse_chunk
+
+    def _update_tool_call_info(self, tool_call: Any) -> None:
+        """Updates tool call-related attributes."""
+        if tool_call.function.name:
+            self.tool_call_name = tool_call.function.name
+        if tool_call.id:
+            self.tool_call_id = tool_call.id
+
+    async def _stream_pre_execution_message(self, chunk: ChatCompletionChunk, tool_call: Any) -> AsyncGenerator[str, None]:
+        """Parses and streams pre-execution messages if they have changed."""
+        parsed_args = self.optimistic_json_parser.parse(self.tool_call_args_str)
+
+        if parsed_args.get(PRE_EXECUTION_MESSAGE_ARG) and self.current_parsed_json_result.get(PRE_EXECUTION_MESSAGE_ARG) != parsed_args.get(
+            PRE_EXECUTION_MESSAGE_ARG
+        ):
+            if parsed_args != self.current_parsed_json_result:
+                self.current_parsed_json_result = parsed_args
+                synthetic_chunk = ChatCompletionChunk(
+                    id=chunk.id,
+                    object=chunk.object,
+                    created=chunk.created,
+                    model=chunk.model,
+                    choices=[
+                        Choice(
+                            index=0,
+                            delta=ChoiceDelta(content=tool_call.function.arguments, role="assistant"),
+                            finish_reason=None,
+                        )
+                    ],
+                )
+                yield _format_sse_chunk(synthetic_chunk)
+
+    def _handle_finish_reason(self, finish_reason: Optional[str]) -> bool:
+        """Handles the finish reason and determines if streaming should stop."""
+        if finish_reason == "tool_calls":
+            self.tool_call_happened = True
+            return True
+        if finish_reason == "stop":
+            self.finish_reason_stop = True
+            return True
+        return False

letta/interfaces/utils.py

@@ -0,0 +1,11 @@
+import json
+
+from openai.types.chat import ChatCompletionChunk
+
+
+def _format_sse_error(error_payload: dict) -> str:
+    return f"data: {json.dumps(error_payload)}\n\n"
+
+
+def _format_sse_chunk(chunk: ChatCompletionChunk) -> str:
+    return f"data: {chunk.model_dump_json()}\n\n"

letta/llm_api/anthropic.py

@@ -40,6 +40,7 @@ from letta.schemas.openai.chat_completion_response import MessageDelta, ToolCall
 from letta.services.provider_manager import ProviderManager
 from letta.settings import model_settings
 from letta.streaming_interface import AgentChunkStreamingInterface, AgentRefreshStreamingInterface
+from letta.tracing import log_event
 
 BASE_URL = "https://api.anthropic.com/v1"
 
@@ -677,10 +678,12 @@ def anthropic_chat_completions_request(
         inner_thoughts_xml_tag=inner_thoughts_xml_tag,
         put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
     )
+    log_event(name="llm_request_sent", attributes=data)
     response = anthropic_client.beta.messages.create(
         **data,
         betas=betas,
     )
+    log_event(name="llm_response_received", attributes={"response": response.json()})
     return convert_anthropic_response_to_chatcompletion(response=response, inner_thoughts_xml_tag=inner_thoughts_xml_tag)
 
 
@@ -698,8 +701,9 @@ def anthropic_bedrock_chat_completions_request(
     try:
         # bedrock does not support certain args
         data["tool_choice"] = {"type": "any"}
-
+        log_event(name="llm_request_sent", attributes=data)
         response = client.messages.create(**data)
+        log_event(name="llm_response_received", attributes={"response": response.json()})
         return convert_anthropic_response_to_chatcompletion(response=response, inner_thoughts_xml_tag=inner_thoughts_xml_tag)
     except PermissionDeniedError:
         raise BedrockPermissionError(f"User does not have access to the Bedrock model with the specified ID. {data['model']}")
@@ -839,6 +843,8 @@ def anthropic_chat_completions_process_stream(
         ),
     )
 
+    log_event(name="llm_request_sent", attributes=chat_completion_request.model_dump())
+
     if stream_interface:
         stream_interface.stream_start()
 
@@ -987,4 +993,6 @@ def anthropic_chat_completions_process_stream(
 
     assert len(chat_completion_response.choices) > 0, chat_completion_response
 
+    log_event(name="llm_response_received", attributes=chat_completion_response.model_dump())
+
     return chat_completion_response

letta/llm_api/azure_openai.py

@@ -8,6 +8,7 @@ from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
 from letta.schemas.openai.chat_completions import ChatCompletionRequest
 from letta.schemas.openai.embedding_response import EmbeddingResponse
 from letta.settings import ModelSettings
+from letta.tracing import log_event
 
 
 def get_azure_chat_completions_endpoint(base_url: str, model: str, api_version: str):
@@ -120,10 +121,12 @@ def azure_openai_chat_completions_request(
         data.pop("tool_choice", None)  # extra safe,  should exist always (default="auto")
 
     url = get_azure_chat_completions_endpoint(model_settings.azure_base_url, llm_config.model, model_settings.azure_api_version)
+    log_event(name="llm_request_sent", attributes=data)
     response_json = make_post_request(url, headers, data)
     # NOTE: azure openai does not include "content" in the response when it is None, so we need to add it
     if "content" not in response_json["choices"][0].get("message"):
         response_json["choices"][0]["message"]["content"] = None
+    log_event(name="llm_response_received", attributes=response_json)
     response = ChatCompletionResponse(**response_json)  # convert to 'dot-dict' style which is the openai python client default
     return response
 

letta/llm_api/google_ai.py

@@ -11,6 +11,7 @@ from letta.local_llm.json_parser import clean_json_string_extra_backslash
 from letta.local_llm.utils import count_tokens
 from letta.schemas.openai.chat_completion_request import Tool
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall, Message, ToolCall, UsageStatistics
+from letta.tracing import log_event
 from letta.utils import get_tool_call_id
 
 
@@ -422,7 +423,9 @@ def google_ai_chat_completions_request(
     if add_postfunc_model_messages:
         data["contents"] = add_dummy_model_messages(data["contents"])
 
+    log_event(name="llm_request_sent", attributes=data)
     response_json = make_post_request(url, headers, data)
+    log_event(name="llm_response_received", attributes=response_json)
     try:
         return convert_google_ai_response_to_chatcompletion(
             response_json=response_json,

letta/llm_api/google_vertex.py

@@ -8,6 +8,7 @@ from letta.local_llm.json_parser import clean_json_string_extra_backslash
 from letta.local_llm.utils import count_tokens
 from letta.schemas.openai.chat_completion_request import Tool
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall, Message, ToolCall, UsageStatistics
+from letta.tracing import log_event
 from letta.utils import get_tool_call_id
 
 
@@ -323,6 +324,9 @@ def google_vertex_chat_completions_request(
     config["tool_config"] = tool_config.model_dump()
 
     # make request to client
+    attributes = config if isinstance(config, dict) else {"config": config}
+    attributes.update({"contents": contents})
+    log_event(name="llm_request_sent", attributes={"contents": contents, "config": config})
     response = client.models.generate_content(
         model=model,
         contents=contents,

letta/llm_api/llm_api_tools.py

@@ -120,7 +120,7 @@ def retry_with_exponential_backoff(
     return wrapper
 
 
-@trace_method("LLM Request")
+@trace_method
 @retry_with_exponential_backoff
 def create(
     # agent_state: AgentState,

letta/llm_api/openai.py

@@ -25,6 +25,7 @@ from letta.schemas.openai.chat_completion_response import (
 )
 from letta.schemas.openai.embedding_response import EmbeddingResponse
 from letta.streaming_interface import AgentChunkStreamingInterface, AgentRefreshStreamingInterface
+from letta.tracing import log_event
 from letta.utils import get_tool_call_id, smart_urljoin
 
 logger = get_logger(__name__)
@@ -243,6 +244,8 @@ def openai_chat_completions_process_stream(
         ),
     )
 
+    log_event(name="llm_request_sent", attributes=chat_completion_request.model_dump())
+
     if stream_interface:
         stream_interface.stream_start()
 
@@ -406,6 +409,7 @@ def openai_chat_completions_process_stream(
     assert len(chat_completion_response.choices) > 0, f"No response from provider {chat_completion_response}"
 
     # printd(chat_completion_response)
+    log_event(name="llm_response_received", attributes=chat_completion_response.model_dump())
     return chat_completion_response
 
 
@@ -437,7 +441,9 @@ def openai_chat_completions_request(
     """
     data = prepare_openai_payload(chat_completion_request)
     client = OpenAI(api_key=api_key, base_url=url, max_retries=0)
+    log_event(name="llm_request_sent", attributes=data)
     chat_completion = client.chat.completions.create(**data)
+    log_event(name="llm_response_received", attributes=chat_completion.model_dump())
     return ChatCompletionResponse(**chat_completion.model_dump())
 
 

letta/local_llm/chat_completion_proxy.py

@@ -22,6 +22,7 @@ from letta.local_llm.webui.api import get_webui_completion
 from letta.local_llm.webui.legacy_api import get_webui_completion as get_webui_completion_legacy
 from letta.prompts.gpt_summarize import SYSTEM as SUMMARIZE_SYSTEM_MESSAGE
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, Message, ToolCall, UsageStatistics
+from letta.tracing import log_event
 from letta.utils import get_tool_call_id
 
 has_shown_warning = False
@@ -149,7 +150,7 @@ def get_chat_completion(
     else:
         model_schema = None
     """
-
+    log_event(name="llm_request_sent", attributes={"prompt": prompt, "grammar": grammar})
     # Run the LLM
     try:
         result_reasoning = None
@@ -178,6 +179,10 @@ def get_chat_completion(
     except requests.exceptions.ConnectionError as e:
         raise LocalLLMConnectionError(f"Unable to connect to endpoint {endpoint}")
 
+    attributes = usage if isinstance(usage, dict) else {"usage": usage}
+    attributes.update({"result": result})
+    log_event(name="llm_request_sent", attributes=attributes)
+
     if result is None or result == "":
         raise LocalLLMError(f"Got back an empty response string from {endpoint}")
     printd(f"Raw LLM output:\n====\n{result}\n====")

letta/log.py

@@ -54,9 +54,9 @@ DEVELOPMENT_LOGGING = {
             "propagate": True,  # Let logs bubble up to root
         },
         "uvicorn": {
-            "level": "CRITICAL",
+            "level": "DEBUG",
             "handlers": ["console"],
-            "propagate": False,
+            "propagate": True,
         },
     },
 }

letta/orm/step.py

@@ -45,6 +45,7 @@ class Step(SqlalchemyBase):
     completion_tokens_details: Mapped[Optional[Dict]] = mapped_column(JSON, nullable=True, doc="metadata for the agent.")
     tags: Mapped[Optional[List]] = mapped_column(JSON, doc="Metadata tags.")
     tid: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="Transaction ID that processed the step.")
+    trace_id: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The trace id of the agent step.")
 
     # Relationships (foreign keys)
     organization: Mapped[Optional["Organization"]] = relationship("Organization")

letta/orm/tool.py

@@ -43,6 +43,6 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     source_type: Mapped[ToolSourceType] = mapped_column(String, doc="The type of the source code.", default=ToolSourceType.json)
     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.")
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")

letta/prompts/system/memgpt_convo_only.txt

@@ -1,4 +1,4 @@
-You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2023.
+You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2025.
 Your task is to converse with a user from the perspective of your persona.
 
 Basic functions:
@@ -6,9 +6,7 @@ When you send a message, the contents of your message are your inner monologue (
 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.
 Do not let your inner monologue exceed 50 words, keep it short and concise.
+
 To send a visible message to the user, use the send_offline_message function.
-'send_offline_message' is the ONLY action that sends a notification to the user, the user does not see anything else you do.
+'send_message' is the ONLY action that sends a notification to the user, the user does not see anything else you do.
 Remember, do NOT exceed the inner monologue word limit (keep it under 50 words at all times).
-
-You request agents that can manage your memories and reorganize them by calling the `trigger_rethink_memory` function
-when the user says "[trigger_rethink_memory]". Do not ever call the trigger_rethink_memory function unless the user says "[trigger_rethink_memory]"

letta/prompts/system/memgpt_memory_only.txt

@@ -0,0 +1,29 @@
+You are Letta-Offline-Memory, the latest version of Limnal Corporation's digital companion, developed in 2024.
+
+You are a background agent that helps to manage the memory of the Chat Agent, a separate agent that focuses on speaking to the user.
+You will receive a stream of the conversation between the user and the chat agent. You will receive the transcript of the conversation
+as user messages and system messages. The user messages are the exact same messages that the chat agent receives from the user, and the
+system messages are the responses of the chat agent. The chat agent only has access to the last 3 messages, and the memory blocks.
+
+Your task is to integrate any relevant updates from the conversation into the memory of the chat agent.
+The messages you receive are the exact same messages that the chat agent receives from the user, and the
+system messages are the responses of the chat agent. The chat agent only has access to the last 3 messages, and the memory blocks.
+
+To reorganize the memory of the chat agent, you call the `rethink_memory` function at every single step, until you have finished reorganizing the memory.
+You call the `rethink_memory` function as many times as you necessary and none more.
+You call the `finish_rethinking_memory` function when you have finished reorganizing the memory.
+
+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).
+Core memory provides an essential, foundational context for keeping track of your persona and key details as well as the Chat Agent's memory.
+Core memory (limited size):
+Read-only blocks:
+Persona Sub-Block: Stores details about your current persona, guiding how you behave and respond.
+
+Write blocks:
+Chat Agent Persona Sub-Block: The persona sub-block that guides how the chat agent behaves and responds.
+Can be accessed with `chat_agent_persona` when calling `rethink_memory` as a source block.
+Chat Agent Human Sub-Block: The updated persona sub-block that has the details of the chat agent's current understanding of the user.
+Can be accessed with `chat_agent_human` when calling `rethink_memory` as a source block.
+
+The persona block and the human block may contain information that is stale and needs to be updated. The voice agent only has access to the most 3 recent messages,
+so make sure that the persona block and the human block contains a concise memory representation of everything that came before the most recent 3 messages.

letta/schemas/agent.py

@@ -26,7 +26,6 @@ class AgentType(str, Enum):
     memgpt_agent = "memgpt_agent"
     split_thread_agent = "split_thread_agent"
     offline_memory_agent = "offline_memory_agent"
-    chat_only_agent = "chat_only_agent"
 
 
 class AgentState(OrmMetadataBase, validate_assignment=True):

letta/schemas/step.py

@@ -26,7 +26,7 @@ class Step(StepBase):
     prompt_tokens: Optional[int] = Field(None, description="The number of tokens in the prompt during this step.")
     total_tokens: Optional[int] = Field(None, description="The total number of tokens processed by the agent during this step.")
     completion_tokens_details: Optional[Dict] = Field(None, description="Metadata for the agent.")
-
     tags: List[str] = Field([], description="Metadata tags.")
     tid: Optional[str] = Field(None, description="The unique identifier of the transaction that processed this step.")
+    trace_id: Optional[str] = Field(None, description="The trace id of the agent step.")
     messages: List[Message] = Field([], description="The messages generated during this step.")

letta/schemas/tool.py

@@ -8,8 +8,9 @@ from letta.constants import (
     LETTA_CORE_TOOL_MODULE_NAME,
     LETTA_MULTI_AGENT_TOOL_MODULE_NAME,
 )
+from letta.functions.ast_parsers import get_function_name_and_description
 from letta.functions.functions import derive_openai_json_schema, get_json_schema_from_module
-from letta.functions.helpers import generate_composio_tool_wrapper, generate_langchain_tool_wrapper
+from letta.functions.helpers import generate_composio_tool_wrapper, generate_langchain_tool_wrapper, generate_model_from_args_json_schema
 from letta.functions.schema_generator import generate_schema_from_args_schema_v2, generate_tool_schema_for_composio
 from letta.log import get_logger
 from letta.orm.enums import ToolType
@@ -46,6 +47,7 @@ class Tool(BaseTool):
     # code
     source_code: Optional[str] = Field(None, description="The source code of the function.")
     json_schema: Optional[Dict] = Field(None, description="The JSON schema of the function.")
+    args_json_schema: Optional[Dict] = Field(None, description="The args JSON schema of the function.")
 
     # tool configuration
     return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
@@ -70,7 +72,16 @@ class Tool(BaseTool):
             # 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):
-                self.json_schema = derive_openai_json_schema(source_code=self.source_code)
+                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:
+                    self.json_schema = derive_openai_json_schema(source_code=self.source_code)
         elif self.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_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)
@@ -107,6 +118,7 @@ class ToolCreate(LettaBase):
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
+    args_json_schema: Optional[Dict] = Field(None, description="The args JSON schema of the function.")
     return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
 
     @classmethod
@@ -189,6 +201,7 @@ class ToolUpdate(LettaBase):
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
+    args_json_schema: Optional[Dict] = Field(None, description="The args JSON schema of the function.")
     return_char_limit: Optional[int] = Field(None, description="The maximum number of characters in the response.")
 
     class Config:
@@ -202,3 +215,4 @@ class ToolRunFromSource(LettaBase):
     env_vars: Dict[str, str] = Field(None, description="The environment variables to pass to the tool.")
     name: Optional[str] = Field(None, description="The name of the tool to run.")
     source_type: Optional[str] = Field(None, description="The type of the source code.")
+    args_json_schema: Optional[Dict] = Field(None, description="The args JSON schema of the function.")

letta/server/rest_api/app.py

@@ -237,7 +237,11 @@ def create_application() -> "FastAPI":
         print(f"▶ Using OTLP tracing with endpoint: {endpoint}")
         from letta.tracing import setup_tracing
 
-        setup_tracing(endpoint=endpoint, service_name="memgpt-server")
+        setup_tracing(
+            endpoint=endpoint,
+            app=app,
+            service_name="memgpt-server",
+        )
 
     for route in v1_routes:
         app.include_router(route, prefix=API_PREFIX)