letta-nightly 0.6.34.dev20250303104329__tar.gz → 0.6.34.dev20250303230404__tar.gz

{letta_nightly-0.6.34.dev20250303104329 → letta_nightly-0.6.34.dev20250303230404}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.34.dev20250303104329
+Version: 0.6.34.dev20250303230404
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -30,6 +30,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.2,<0.8.0)
 Requires-Dist: composio-langchain (>=0.7.2,<0.8.0)
+Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0)
 Requires-Dist: datasets (>=2.14.6,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
 Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools" or extra == "all"
@@ -56,10 +57,10 @@ Requires-Dist: marshmallow-sqlalchemy (>=1.4.1,<2.0.0)
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=1.26.2,<2.0.0)
 Requires-Dist: openai (>=1.60.0,<2.0.0)
-Requires-Dist: opentelemetry-api (>=1.30.0,<2.0.0)
-Requires-Dist: opentelemetry-exporter-otlp (>=1.30.0,<2.0.0)
-Requires-Dist: opentelemetry-instrumentation-requests (>=0.51b0,<0.52)
-Requires-Dist: opentelemetry-sdk (>=1.30.0,<2.0.0)
+Requires-Dist: opentelemetry-api (==1.30.0)
+Requires-Dist: opentelemetry-exporter-otlp (==1.30.0)
+Requires-Dist: opentelemetry-instrumentation-requests (==0.51b0)
+Requires-Dist: opentelemetry-sdk (==1.30.0)
 Requires-Dist: pathvalidate (>=3.2.1,<4.0.0)
 Requires-Dist: pexpect (>=4.9.0,<5.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: pg8000 (>=1.30.3,<2.0.0) ; extra == "postgres" or extra == "all"

{letta_nightly-0.6.34.dev20250303104329 → letta_nightly-0.6.34.dev20250303230404}/letta/__init__.py

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

{letta_nightly-0.6.34.dev20250303104329 → letta_nightly-0.6.34.dev20250303230404}/letta/agent.py

@@ -60,16 +60,8 @@ from letta.services.tool_manager import ToolManager
 from letta.settings import summarizer_settings
 from letta.streaming_interface import StreamingRefreshCLIInterface
 from letta.system import get_heartbeat, get_token_limit_warning, package_function_response, package_summarize_message, package_user_message
-from letta.tracing import trace_method
-from letta.utils import (
-    count_tokens,
-    get_friendly_error_msg,
-    get_tool_call_id,
-    log_telemetry,
-    parse_json,
-    printd,
-    validate_function_response,
-)
+from letta.tracing import log_event, trace_method
+from letta.utils import count_tokens, get_friendly_error_msg, get_tool_call_id, log_telemetry, parse_json, validate_function_response
 
 logger = get_logger(__name__)
 
@@ -315,7 +307,7 @@ class Agent(BaseAgent):
         # Return updated messages
         return messages
 
-    @trace_method("Get AI Reply")
+    @trace_method
     def _get_ai_reply(
         self,
         message_sequence: List[Message],
@@ -408,7 +400,7 @@ class Agent(BaseAgent):
         log_telemetry(self.logger, "_handle_ai_response finish catch-all exception")
         raise Exception("Retries exhausted and no valid response received.")
 
-    @trace_method("Handle AI Response")
+    @trace_method
     def _handle_ai_response(
         self,
         response_message: ChatCompletionMessage,  # TODO should we eventually move the Message creation outside of this function?
@@ -546,7 +538,24 @@ class Agent(BaseAgent):
                 log_telemetry(
                     self.logger, "_handle_ai_response execute tool start", function_name=function_name, function_args=function_args
                 )
+                log_event(
+                    "tool_call_initiated",
+                    attributes={
+                        "function_name": function_name,
+                        "target_letta_tool": target_letta_tool.model_dump(),
+                        **{f"function_args.{k}": v for k, v in function_args.items()},
+                    },
+                )
+
                 function_response, sandbox_run_result = self.execute_tool_and_persist_state(function_name, function_args, target_letta_tool)
+
+                log_event(
+                    "tool_call_ended",
+                    attributes={
+                        "function_response": function_response,
+                        "sandbox_run_result": sandbox_run_result.model_dump() if sandbox_run_result else None,
+                    },
+                )
                 log_telemetry(
                     self.logger, "_handle_ai_response execute tool finish", function_name=function_name, function_args=function_args
                 )
@@ -648,7 +657,7 @@ class Agent(BaseAgent):
         log_telemetry(self.logger, "_handle_ai_response finish")
         return messages, heartbeat_request, function_failed
 
-    @trace_method("Agent Step")
+    @trace_method
     def step(
         self,
         messages: Union[Message, List[Message]],
@@ -836,6 +845,13 @@ class Agent(BaseAgent):
                     f"{CLI_WARNING_PREFIX}last response total_tokens ({current_total_tokens}) > {summarizer_settings.memory_warning_threshold * int(self.agent_state.llm_config.context_window)}"
                 )
 
+                log_event(
+                    name="memory_pressure_warning",
+                    attributes={
+                        "current_total_tokens": current_total_tokens,
+                        "context_window_limit": self.agent_state.llm_config.context_window,
+                    },
+                )
                 # Only deliver the alert if we haven't already (this period)
                 if not self.agent_alerted_about_memory_pressure:
                     active_memory_warning = True
@@ -1037,9 +1053,18 @@ class Agent(BaseAgent):
         self.agent_alerted_about_memory_pressure = False
         curr_in_context_messages = self.agent_manager.get_in_context_messages(agent_id=self.agent_state.id, actor=self.user)
 
+        current_token_count = sum(get_token_counts_for_messages(curr_in_context_messages))
         logger.info(f"Ran summarizer, messages length {prior_len} -> {len(curr_in_context_messages)}")
-        logger.info(
-            f"Summarizer brought down total token count from {sum(token_counts)} -> {sum(get_token_counts_for_messages(curr_in_context_messages))}"
+        logger.info(f"Summarizer brought down total token count from {sum(token_counts)} -> {current_token_count}")
+        log_event(
+            name="summarization",
+            attributes={
+                "prior_length": prior_len,
+                "current_length": len(curr_in_context_messages),
+                "prior_token_count": sum(token_counts),
+                "current_token_count": current_token_count,
+                "context_window_limit": self.agent_state.llm_config.context_window,
+            },
         )
 
     def add_function(self, function_name: str) -> str:

letta_nightly-0.6.34.dev20250303230404/letta/agents/base_agent.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+from typing import Any, AsyncGenerator, List
+
+import openai
+
+from letta.schemas.letta_message import UserMessage
+from letta.schemas.message import Message
+from letta.schemas.user import User
+from letta.services.agent_manager import AgentManager
+from letta.services.message_manager import MessageManager
+
+
+class BaseAgent(ABC):
+    """
+    Abstract base class for AI agents, handling message management, tool execution,
+    and context tracking.
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        openai_client: openai.AsyncClient,
+        message_manager: MessageManager,
+        agent_manager: AgentManager,
+        actor: User,
+    ):
+        self.agent_id = agent_id
+        self.openai_client = openai_client
+        self.message_manager = message_manager
+        self.agent_manager = agent_manager
+        self.actor = actor
+
+    @abstractmethod
+    async def step(self, input_message: UserMessage) -> List[Message]:
+        """
+        Main execution loop for the agent.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def step_stream(self, input_message: UserMessage) -> AsyncGenerator[str, None]:
+        """
+        Main async execution loop for the agent. Implementations must yield messages as SSE events.
+        """
+        raise NotImplementedError
+
+    def pre_process_input_message(self, input_message: UserMessage) -> Any:
+        """
+        Pre-process function to run on the input_message.
+        """
+        return input_message.model_dump()

letta_nightly-0.6.34.dev20250303230404/letta/agents/ephemeral_agent.py

@@ -0,0 +1,72 @@
+from typing import AsyncGenerator, Dict, List
+
+import openai
+
+from letta.agents.base_agent import BaseAgent
+from letta.schemas.agent import AgentState
+from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message import TextContent, UserMessage
+from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
+from letta.schemas.user import User
+from letta.services.agent_manager import AgentManager
+from letta.services.message_manager import MessageManager
+
+
+class EphemeralAgent(BaseAgent):
+    """
+    A stateless agent (thin wrapper around OpenAI)
+
+    # TODO: Extend to more clients
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        openai_client: openai.AsyncClient,
+        message_manager: MessageManager,
+        agent_manager: AgentManager,
+        actor: User,
+    ):
+        super().__init__(
+            agent_id=agent_id,
+            openai_client=openai_client,
+            message_manager=message_manager,
+            agent_manager=agent_manager,
+            actor=actor,
+        )
+
+    async def step(self, input_message: UserMessage) -> List[Message]:
+        """
+        Synchronous method that takes a user's input text and returns a summary from OpenAI.
+        Returns a list of ephemeral Message objects containing both the user text and the assistant summary.
+        """
+        agent_state = self.agent_manager.get_agent_by_id(agent_id=self.agent_id, actor=self.actor)
+
+        input_message = self.pre_process_input_message(input_message=input_message)
+        request = self._build_openai_request([input_message], agent_state)
+
+        chat_completion = await self.openai_client.chat.completions.create(**request.model_dump(exclude_unset=True))
+
+        return [
+            Message(
+                role=MessageRole.assistant,
+                content=[TextContent(text=chat_completion.choices[0].message.content.strip())],
+            )
+        ]
+
+    def _build_openai_request(self, openai_messages: List[Dict], agent_state: AgentState) -> ChatCompletionRequest:
+        openai_request = ChatCompletionRequest(
+            model=agent_state.llm_config.model,
+            messages=openai_messages,
+            user=self.actor.id,
+            max_completion_tokens=agent_state.llm_config.max_tokens,
+            temperature=agent_state.llm_config.temperature,
+        )
+        return openai_request
+
+    async def step_stream(self, input_message: UserMessage) -> AsyncGenerator[str, None]:
+        """
+        This agent is synchronous-only. If called in an async context, raise an error.
+        """
+        raise NotImplementedError("EphemeralAgent does not support async step.")

letta_nightly-0.6.34.dev20250303230404/letta/agents/low_latency_agent.py

@@ -0,0 +1,315 @@
+import json
+import uuid
+from typing import Any, AsyncGenerator, Dict, List, Tuple
+
+import openai
+
+from letta.agents.base_agent import BaseAgent
+from letta.agents.ephemeral_agent import EphemeralAgent
+from letta.constants import NON_USER_MSG_PREFIX
+from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.tool_execution_helper import (
+    add_pre_execution_message,
+    enable_strict_mode,
+    execute_external_tool,
+    remove_request_heartbeat,
+)
+from letta.interfaces.openai_chat_completions_streaming_interface import OpenAIChatCompletionsStreamingInterface
+from letta.log import get_logger
+from letta.orm.enums import ToolType
+from letta.schemas.agent import AgentState
+from letta.schemas.block import BlockUpdate
+from letta.schemas.message import Message, MessageUpdate
+from letta.schemas.openai.chat_completion_request import (
+    AssistantMessage,
+    ChatCompletionRequest,
+    Tool,
+    ToolCall,
+    ToolCallFunction,
+    ToolMessage,
+    UserMessage,
+)
+from letta.schemas.user import User
+from letta.server.rest_api.utils import (
+    convert_letta_messages_to_openai,
+    create_assistant_messages_from_openai_response,
+    create_tool_call_messages_from_openai_response,
+    create_user_message,
+)
+from letta.services.agent_manager import AgentManager
+from letta.services.block_manager import BlockManager
+from letta.services.helpers.agent_manager_helper import compile_system_message
+from letta.services.message_manager import MessageManager
+from letta.services.summarizer.enums import SummarizationMode
+from letta.services.summarizer.summarizer import Summarizer
+from letta.utils import united_diff
+
+logger = get_logger(__name__)
+
+
+class LowLatencyAgent(BaseAgent):
+    """
+    A function-calling loop for streaming OpenAI responses with tool execution.
+    This agent:
+      - Streams partial tokens in real-time for low-latency output.
+      - Detects tool calls and invokes external tools.
+      - Gracefully handles OpenAI API failures (429, etc.) and streams errors.
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        openai_client: openai.AsyncClient,
+        message_manager: MessageManager,
+        agent_manager: AgentManager,
+        block_manager: BlockManager,
+        actor: User,
+        summarization_mode: SummarizationMode = SummarizationMode.STATIC_MESSAGE_BUFFER,
+        message_buffer_limit: int = 10,
+        message_buffer_min: int = 4,
+    ):
+        super().__init__(
+            agent_id=agent_id, openai_client=openai_client, message_manager=message_manager, agent_manager=agent_manager, actor=actor
+        )
+
+        # TODO: Make this more general, factorable
+        # Summarizer settings
+        self.block_manager = block_manager
+        # TODO: This is not guaranteed to exist!
+        self.summary_block_label = "human"
+        self.summarizer = Summarizer(
+            mode=summarization_mode,
+            summarizer_agent=EphemeralAgent(
+                agent_id=agent_id, openai_client=openai_client, message_manager=message_manager, agent_manager=agent_manager, actor=actor
+            ),
+            message_buffer_limit=message_buffer_limit,
+            message_buffer_min=message_buffer_min,
+        )
+        self.message_buffer_limit = message_buffer_limit
+        self.message_buffer_min = message_buffer_min
+
+    async def step(self, input_message: UserMessage) -> List[Message]:
+        raise NotImplementedError("LowLatencyAgent does not have a synchronous step implemented currently.")
+
+    async def step_stream(self, input_message: UserMessage) -> AsyncGenerator[str, None]:
+        """
+        Async generator that yields partial tokens as SSE events, handles tool calls,
+        and streams error messages if OpenAI API failures occur.
+        """
+        input_message = self.pre_process_input_message(input_message=input_message)
+        agent_state = self.agent_manager.get_agent_by_id(agent_id=self.agent_id, actor=self.actor)
+        in_context_messages = self.message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=self.actor)
+        letta_message_db_queue = [create_user_message(input_message=input_message, agent_id=agent_state.id, actor=self.actor)]
+        in_memory_message_history = [input_message]
+
+        while True:
+            # Constantly pull down and integrate memory blocks
+            in_context_messages = self._rebuild_memory(in_context_messages=in_context_messages, agent_state=agent_state)
+
+            # Convert Letta messages to OpenAI messages
+            openai_messages = convert_letta_messages_to_openai(in_context_messages)
+            openai_messages.extend(in_memory_message_history)
+            request = self._build_openai_request(openai_messages, agent_state)
+
+            # Execute the request
+            stream = await self.openai_client.chat.completions.create(**request.model_dump(exclude_unset=True))
+            streaming_interface = OpenAIChatCompletionsStreamingInterface(stream_pre_execution_message=True)
+
+            async for sse in streaming_interface.process(stream):
+                yield sse
+
+            # Process the AI response (buffered messages, tool execution, etc.)
+            continue_execution = await self._handle_ai_response(
+                streaming_interface, agent_state, in_memory_message_history, letta_message_db_queue
+            )
+
+            if not continue_execution:
+                break
+
+        # Rebuild context window
+        await self._rebuild_context_window(in_context_messages, letta_message_db_queue, agent_state)
+
+        yield "data: [DONE]\n\n"
+
+    async def _handle_ai_response(
+        self,
+        streaming_interface: OpenAIChatCompletionsStreamingInterface,
+        agent_state: AgentState,
+        in_memory_message_history: List[Dict[str, Any]],
+        letta_message_db_queue: List[Any],
+    ) -> bool:
+        """
+        Handles AI response processing, including buffering messages, detecting tool calls,
+        executing tools, and deciding whether to continue execution.
+
+        Returns:
+            bool: True if execution should continue, False if the step loop should terminate.
+        """
+        # Handle assistant message buffering
+        if streaming_interface.content_buffer:
+            content = "".join(streaming_interface.content_buffer)
+            in_memory_message_history.append({"role": "assistant", "content": content})
+
+            assistant_msgs = create_assistant_messages_from_openai_response(
+                response_text=content,
+                agent_id=agent_state.id,
+                model=agent_state.llm_config.model,
+                actor=self.actor,
+            )
+            letta_message_db_queue.extend(assistant_msgs)
+
+        # Handle tool execution if a tool call occurred
+        if streaming_interface.tool_call_happened:
+            try:
+                tool_args = json.loads(streaming_interface.tool_call_args_str)
+            except json.JSONDecodeError:
+                tool_args = {}
+
+            tool_call_id = streaming_interface.tool_call_id or f"call_{uuid.uuid4().hex[:8]}"
+
+            assistant_tool_call_msg = AssistantMessage(
+                content=None,
+                tool_calls=[
+                    ToolCall(
+                        id=tool_call_id,
+                        function=ToolCallFunction(
+                            name=streaming_interface.tool_call_name,
+                            arguments=streaming_interface.tool_call_args_str,
+                        ),
+                    )
+                ],
+            )
+            in_memory_message_history.append(assistant_tool_call_msg.model_dump())
+
+            tool_result, function_call_success = await self._execute_tool(
+                tool_name=streaming_interface.tool_call_name,
+                tool_args=tool_args,
+                agent_state=agent_state,
+            )
+
+            tool_message = ToolMessage(content=json.dumps({"result": tool_result}), tool_call_id=tool_call_id)
+            in_memory_message_history.append(tool_message.model_dump())
+
+            heartbeat_user_message = UserMessage(
+                content=f"{NON_USER_MSG_PREFIX} Tool finished executing. Summarize the result for the user."
+            )
+            in_memory_message_history.append(heartbeat_user_message.model_dump())
+
+            tool_call_messages = create_tool_call_messages_from_openai_response(
+                agent_id=agent_state.id,
+                model=agent_state.llm_config.model,
+                function_name=streaming_interface.tool_call_name,
+                function_arguments=tool_args,
+                tool_call_id=tool_call_id,
+                function_call_success=function_call_success,
+                function_response=tool_result,
+                actor=self.actor,
+                add_heartbeat_request_system_message=True,
+            )
+            letta_message_db_queue.extend(tool_call_messages)
+
+            # Continue execution by restarting the loop with updated context
+            return True
+
+        # Exit the loop if finish_reason_stop or no tool call occurred
+        return not streaming_interface.finish_reason_stop
+
+    async def _rebuild_context_window(
+        self, in_context_messages: List[Message], letta_message_db_queue: List[Message], agent_state: AgentState
+    ) -> None:
+        new_letta_messages = self.message_manager.create_many_messages(letta_message_db_queue, actor=self.actor)
+
+        # TODO: Make this more general and configurable, less brittle
+        target_block = next(b for b in agent_state.memory.blocks if b.label == self.summary_block_label)
+        previous_summary = self.block_manager.get_block_by_id(block_id=target_block.id, actor=self.actor).value
+        new_in_context_messages, summary_str, updated = await self.summarizer.summarize(
+            in_context_messages=in_context_messages, new_letta_messages=new_letta_messages, previous_summary=previous_summary
+        )
+
+        if updated:
+            self.block_manager.update_block(block_id=target_block.id, block_update=BlockUpdate(value=summary_str), actor=self.actor)
+
+        self.agent_manager.set_in_context_messages(
+            agent_id=self.agent_id, message_ids=[m.id for m in new_in_context_messages], actor=self.actor
+        )
+
+    def _rebuild_memory(self, in_context_messages: List[Message], agent_state: AgentState) -> List[Message]:
+        # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
+        curr_system_message = in_context_messages[0]
+        curr_memory_str = agent_state.memory.compile()
+        if curr_memory_str in curr_system_message.text:
+            # NOTE: could this cause issues if a block is removed? (substring match would still work)
+            logger.debug(
+                f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
+            )
+            return in_context_messages
+
+        memory_edit_timestamp = get_utc_time()
+        new_system_message_str = compile_system_message(
+            system_prompt=agent_state.system,
+            in_context_memory=agent_state.memory,
+            in_context_memory_last_edit=memory_edit_timestamp,
+        )
+
+        diff = united_diff(curr_system_message.text, new_system_message_str)
+        if len(diff) > 0:
+            logger.info(f"Rebuilding system with new memory...\nDiff:\n{diff}")
+
+            new_system_message = self.message_manager.update_message_by_id(
+                curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
+            )
+
+            # Skip pulling down the agent's memory again to save on a db call
+            return [new_system_message] + in_context_messages[1:]
+
+        else:
+            return in_context_messages
+
+    def _build_openai_request(self, openai_messages: List[Dict], agent_state: AgentState) -> ChatCompletionRequest:
+        tool_schemas = self._build_tool_schemas(agent_state)
+        tool_choice = "auto" if tool_schemas else None
+
+        openai_request = ChatCompletionRequest(
+            model=agent_state.llm_config.model,
+            messages=openai_messages,
+            tools=self._build_tool_schemas(agent_state),
+            tool_choice=tool_choice,
+            user=self.actor.id,
+            max_completion_tokens=agent_state.llm_config.max_tokens,
+            temperature=agent_state.llm_config.temperature,
+            stream=True,
+        )
+        return openai_request
+
+    def _build_tool_schemas(self, agent_state: AgentState, external_tools_only=True) -> List[Tool]:
+        if external_tools_only:
+            tools = [t for t in agent_state.tools if t.tool_type in {ToolType.EXTERNAL_COMPOSIO, ToolType.CUSTOM}]
+        else:
+            tools = agent_state.tools
+
+        # TODO: Customize whether or not to have heartbeats, pre_exec_message, etc.
+        return [
+            Tool(type="function", function=enable_strict_mode(add_pre_execution_message(remove_request_heartbeat(t.json_schema))))
+            for t in tools
+        ]
+
+    async def _execute_tool(self, tool_name: str, tool_args: dict, agent_state: AgentState) -> Tuple[str, bool]:
+        """
+        Executes a tool and returns (result, success_flag).
+        """
+        target_tool = next((x for x in agent_state.tools if x.name == tool_name), None)
+        if not target_tool:
+            return f"Tool not found: {tool_name}", False
+
+        try:
+            tool_result, _ = execute_external_tool(
+                agent_state=agent_state,
+                function_name=tool_name,
+                function_args=tool_args,
+                target_letta_tool=target_tool,
+                actor=self.actor,
+                allow_agent_state_modifications=False,
+            )
+            return tool_result, True
+        except Exception as e:
+            return f"Failed to call tool. Error: {e}", False

{letta_nightly-0.6.34.dev20250303104329 → letta_nightly-0.6.34.dev20250303230404}/letta/constants.py

@@ -27,7 +27,6 @@ TOOL_CALL_ID_MAX_LEN = 29
 
 # minimum context window size
 MIN_CONTEXT_WINDOW = 4096
-DEFAULT_CONTEXT_WINDOW_SIZE = 32000
 
 # embeddings
 MAX_EMBEDDING_DIM = 4096  # maximum supported embeding size - do NOT change or else DBs will need to be reset
@@ -96,6 +95,9 @@ LLM_MAX_TOKENS = {
     "deepseek-chat": 64000,
     "deepseek-reasoner": 64000,
     ## OpenAI models: https://platform.openai.com/docs/models/overview
+    # gpt-4.5-preview
+    "gpt-4.5-preview": 128000,
+    "gpt-4.5-preview-2025-02-27": 128000,
     # "o1-preview
     "chatgpt-4o-latest": 128000,
     # "o1-preview-2024-09-12

{letta_nightly-0.6.34.dev20250303104329 → letta_nightly-0.6.34.dev20250303230404}/letta/functions/ast_parsers.py

@@ -1,6 +1,8 @@
 import ast
 import json
-from typing import Dict
+from typing import Dict, Optional, Tuple
+
+from letta.errors import LettaToolCreateError
 
 # Registry of known types for annotation resolution
 BUILTIN_TYPES = {
@@ -116,3 +118,50 @@ def coerce_dict_args_by_annotations(function_args: dict, annotations: Dict[str,
             except (TypeError, ValueError, json.JSONDecodeError, SyntaxError) as e:
                 raise ValueError(f"Failed to coerce argument '{arg_name}' to {annotation_str}: {e}")
     return coerced_args
+
+
+def get_function_name_and_description(source_code: str, name: Optional[str] = None) -> Tuple[str, str]:
+    """Gets the name and description for a given function source code by parsing the AST.
+
+    Args:
+        source_code: The source code to parse
+        name: Optional override for the function name
+
+    Returns:
+        Tuple of (function_name, docstring)
+    """
+    try:
+        # Parse the source code into an AST
+        tree = ast.parse(source_code)
+
+        # Find the last function definition
+        function_def = None
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                function_def = node
+
+        if not function_def:
+            raise LettaToolCreateError("No function definition found in source code")
+
+        # Get the function name
+        function_name = name if name is not None else function_def.name
+
+        # Get the docstring if it exists
+        docstring = ast.get_docstring(function_def)
+
+        if not function_name:
+            raise LettaToolCreateError("Could not determine function name")
+
+        if not docstring:
+            raise LettaToolCreateError("Docstring is missing")
+
+        return function_name, docstring
+
+    except Exception as e:
+        raise LettaToolCreateError(f"Failed to parse function name and docstring: {str(e)}")
+
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc()
+        raise LettaToolCreateError(f"Name and docstring generation failed: {str(e)}")