letta-nightly 0.6.1.dev20241209104258__tar.gz → 0.6.2.dev20241210030252__tar.gz

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.1.dev20241209104258
+Version: 0.6.2.dev20241210030252
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/__init__.py

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

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/agent.py

@@ -801,7 +801,13 @@ class Agent(BaseAgent):
                     # but by default, we add a truncation safeguard to prevent bad functions from
                     # overflow the agent context window
                     truncate = True
-                function_response_string = validate_function_response(function_response, truncate=truncate)
+
+                # get the function response limit
+                tool_obj = [tool for tool in self.agent_state.tools if tool.name == function_name][0]
+                return_char_limit = tool_obj.return_char_limit
+                function_response_string = validate_function_response(
+                    function_response, return_char_limit=return_char_limit, truncate=truncate
+                )
                 function_args.pop("self", None)
                 function_response = package_function_response(True, function_response_string)
                 function_failed = False

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/cli/cli.py

@@ -51,6 +51,7 @@ def server(
     port: Annotated[Optional[int], typer.Option(help="Port to run the server on")] = None,
     host: Annotated[Optional[str], typer.Option(help="Host to run the server on (default to localhost)")] = None,
     debug: Annotated[bool, typer.Option(help="Turn debugging output on")] = False,
+    ade: Annotated[bool, typer.Option(help="Allows remote access")] = False,  # NOTE: deprecated
     secure: Annotated[bool, typer.Option(help="Adds simple security access")] = False,
 ):
     """Launch a Letta server process"""

letta_nightly-0.6.2.dev20241210030252/letta/cli/cli_load.py

@@ -0,0 +1,68 @@
+"""
+This file contains functions for loading data into Letta's archival storage.
+
+Data can be loaded with the following command, once a load function is defined:
+```
+letta load <data-connector-type> --name <dataset-name> [ADDITIONAL ARGS]
+```
+
+"""
+
+import uuid
+from typing import Annotated, List, Optional
+
+import questionary
+import typer
+
+from letta import create_client
+from letta.data_sources.connectors import DirectoryConnector
+
+app = typer.Typer()
+
+
+default_extensions = ".txt,.md,.pdf"
+
+
+@app.command("directory")
+def load_directory(
+    name: Annotated[str, typer.Option(help="Name of dataset to load.")],
+    input_dir: Annotated[Optional[str], typer.Option(help="Path to directory containing dataset.")] = None,
+    input_files: Annotated[List[str], typer.Option(help="List of paths to files containing dataset.")] = [],
+    recursive: Annotated[bool, typer.Option(help="Recursively search for files in directory.")] = False,
+    extensions: Annotated[str, typer.Option(help="Comma separated list of file extensions to load")] = default_extensions,
+    user_id: Annotated[Optional[uuid.UUID], typer.Option(help="User ID to associate with dataset.")] = None,  # TODO: remove
+    description: Annotated[Optional[str], typer.Option(help="Description of the source.")] = None,
+):
+    client = create_client()
+
+    # create connector
+    connector = DirectoryConnector(input_files=input_files, input_directory=input_dir, recursive=recursive, extensions=extensions)
+
+    # choose form list of embedding configs
+    embedding_configs = client.list_embedding_configs()
+    embedding_options = [embedding_config.embedding_model for embedding_config in embedding_configs]
+
+    embedding_choices = [
+        questionary.Choice(title=embedding_config.pretty_print(), value=embedding_config) for embedding_config in embedding_configs
+    ]
+
+    # select model
+    if len(embedding_options) == 0:
+        raise ValueError("No embedding models found. Please enable a provider.")
+    elif len(embedding_options) == 1:
+        embedding_model_name = embedding_options[0]
+    else:
+        embedding_model_name = questionary.select("Select embedding model:", choices=embedding_choices).ask().embedding_model
+    embedding_config = [
+        embedding_config for embedding_config in embedding_configs if embedding_config.embedding_model == embedding_model_name
+    ][0]
+
+    # create source
+    source = client.create_source(name=name, embedding_config=embedding_config)
+
+    # load data
+    try:
+        client.load_data(connector, source_name=name)
+    except Exception as e:
+        typer.secho(f"Failed to load data from provided information.\n{e}", fg=typer.colors.RED)
+        client.delete_source(source.id)

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/client/client.py

@@ -11,6 +11,7 @@ from letta.constants import (
     BASE_TOOLS,
     DEFAULT_HUMAN,
     DEFAULT_PERSONA,
+    FUNCTION_RETURN_CHAR_LIMIT,
 )
 from letta.data_sources.connectors import DataConnector
 from letta.functions.functions import parse_source_code
@@ -200,18 +201,12 @@ class AbstractClient(object):
         raise NotImplementedError
 
     def create_tool(
-        self,
-        func,
-        name: Optional[str] = None,
-        tags: Optional[List[str]] = None,
+        self, func, name: Optional[str] = None, tags: Optional[List[str]] = None, return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT
     ) -> Tool:
         raise NotImplementedError
 
     def create_or_update_tool(
-        self,
-        func,
-        name: Optional[str] = None,
-        tags: Optional[List[str]] = None,
+        self, func, name: Optional[str] = None, tags: Optional[List[str]] = None, return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT
     ) -> Tool:
         raise NotImplementedError
 
@@ -222,6 +217,7 @@ class AbstractClient(object):
         description: Optional[str] = None,
         func: Optional[Callable] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         raise NotImplementedError
 
@@ -960,7 +956,6 @@ class RESTClient(AbstractClient):
         # TODO: figure out how to handle stream_steps and stream_tokens
 
         # When streaming steps is True, stream_tokens must be False
-        request = LettaRequest(messages=messages)
         if stream_tokens or stream_steps:
             from letta.client.streaming import _sse_post
 
@@ -985,6 +980,39 @@ class RESTClient(AbstractClient):
 
             return response
 
+    def send_message_async(
+        self,
+        message: str,
+        role: str,
+        agent_id: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> Job:
+        """
+        Send a message to an agent (async, returns a job)
+
+        Args:
+            message (str): Message to send
+            role (str): Role of the message
+            agent_id (str): ID of the agent
+            name(str): Name of the sender
+
+        Returns:
+            job (Job): Information about the async job
+        """
+        messages = [MessageCreate(role=MessageRole(role), text=message, name=name)]
+
+        request = LettaRequest(messages=messages)
+        response = requests.post(
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/messages/async",
+            json=request.model_dump(),
+            headers=self.headers,
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to send message: {response.text}")
+        response = Job(**response.json())
+
+        return response
+
     # humans / personas
 
     def list_blocks(self, label: Optional[str] = None, templates_only: Optional[bool] = True) -> List[Block]:
@@ -1319,6 +1347,7 @@ class RESTClient(AbstractClient):
         Returns:
             source (Source): Created source
         """
+        assert embedding_config or self._default_embedding_config, f"Must specify embedding_config for source"
         source_create = SourceCreate(name=name, embedding_config=embedding_config or self._default_embedding_config)
         payload = source_create.model_dump()
         response = requests.post(f"{self.base_url}/{self.api_prefix}/sources", json=payload, headers=self.headers)
@@ -1432,6 +1461,7 @@ class RESTClient(AbstractClient):
         func: Callable,
         name: Optional[str] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Create a tool. This stores the source code of function on the server, so that the server can execute the function and generate an OpenAI JSON schemas for it when using with an agent.
@@ -1440,6 +1470,7 @@ class RESTClient(AbstractClient):
             func (callable): The function to create a tool for.
             name: (str): Name of the tool (must be unique per-user.)
             tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): The created tool.
@@ -1448,7 +1479,9 @@ class RESTClient(AbstractClient):
         source_type = "python"
 
         # call server function
-        request = ToolCreate(source_type=source_type, source_code=source_code, name=name, tags=tags)
+        request = ToolCreate(source_type=source_type, source_code=source_code, name=name, return_char_limit=return_char_limit)
+        if tags:
+            request.tags = tags
         response = requests.post(f"{self.base_url}/{self.api_prefix}/tools", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to create tool: {response.text}")
@@ -1459,6 +1492,7 @@ class RESTClient(AbstractClient):
         func: Callable,
         name: Optional[str] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Creates or updates a tool. This stores the source code of function on the server, so that the server can execute the function and generate an OpenAI JSON schemas for it when using with an agent.
@@ -1467,6 +1501,7 @@ class RESTClient(AbstractClient):
             func (callable): The function to create a tool for.
             name: (str): Name of the tool (must be unique per-user.)
             tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): The created tool.
@@ -1475,7 +1510,9 @@ class RESTClient(AbstractClient):
         source_type = "python"
 
         # call server function
-        request = ToolCreate(source_type=source_type, source_code=source_code, name=name, tags=tags)
+        request = ToolCreate(source_type=source_type, source_code=source_code, name=name, return_char_limit=return_char_limit)
+        if tags:
+            request.tags = tags
         response = requests.put(f"{self.base_url}/{self.api_prefix}/tools", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to create tool: {response.text}")
@@ -1488,6 +1525,7 @@ class RESTClient(AbstractClient):
         description: Optional[str] = None,
         func: Optional[Callable] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Update a tool with provided parameters (name, func, tags)
@@ -1497,6 +1535,7 @@ class RESTClient(AbstractClient):
             name (str): Name of the tool
             func (callable): Function to wrap in a tool
             tags (List[str]): Tags for the tool
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): Updated tool
@@ -1508,7 +1547,14 @@ class RESTClient(AbstractClient):
 
         source_type = "python"
 
-        request = ToolUpdate(description=description, source_type=source_type, source_code=source_code, tags=tags, name=name)
+        request = ToolUpdate(
+            description=description,
+            source_type=source_type,
+            source_code=source_code,
+            tags=tags,
+            name=name,
+            return_char_limit=return_char_limit,
+        )
         response = requests.patch(f"{self.base_url}/{self.api_prefix}/tools/{id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update tool: {response.text}")
@@ -2693,6 +2739,7 @@ class LocalClient(AbstractClient):
         name: Optional[str] = None,
         tags: Optional[List[str]] = None,
         description: Optional[str] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Create a tool. This stores the source code of function on the server, so that the server can execute the function and generate an OpenAI JSON schemas for it when using with an agent.
@@ -2702,6 +2749,7 @@ class LocalClient(AbstractClient):
             name: (str): Name of the tool (must be unique per-user.)
             tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
             description (str, optional): The description.
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): The created tool.
@@ -2722,6 +2770,7 @@ class LocalClient(AbstractClient):
                 name=name,
                 tags=tags,
                 description=description,
+                return_char_limit=return_char_limit,
             ),
             actor=self.user,
         )
@@ -2732,6 +2781,7 @@ class LocalClient(AbstractClient):
         name: Optional[str] = None,
         tags: Optional[List[str]] = None,
         description: Optional[str] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Creates or updates a tool. This stores the source code of function on the server, so that the server can execute the function and generate an OpenAI JSON schemas for it when using with an agent.
@@ -2741,6 +2791,7 @@ class LocalClient(AbstractClient):
             name: (str): Name of the tool (must be unique per-user.)
             tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
             description (str, optional): The description.
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): The created tool.
@@ -2758,6 +2809,7 @@ class LocalClient(AbstractClient):
                 name=name,
                 tags=tags,
                 description=description,
+                return_char_limit=return_char_limit,
             ),
             actor=self.user,
         )
@@ -2769,6 +2821,7 @@ class LocalClient(AbstractClient):
         description: Optional[str] = None,
         func: Optional[callable] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Update a tool with provided parameters (name, func, tags)
@@ -2778,6 +2831,7 @@ class LocalClient(AbstractClient):
             name (str): Name of the tool
             func (callable): Function to wrap in a tool
             tags (List[str]): Tags for the tool
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): Updated tool
@@ -2788,6 +2842,7 @@ class LocalClient(AbstractClient):
             "tags": tags,
             "name": name,
             "description": description,
+            "return_char_limit": return_char_limit,
         }
 
         # Filter out any None values from the dictionary
@@ -2896,6 +2951,7 @@ class LocalClient(AbstractClient):
         Returns:
             source (Source): Created source
         """
+        assert embedding_config or self._default_embedding_config, f"Must specify embedding_config for source"
         source = Source(
             name=name, embedding_config=embedding_config or self._default_embedding_config, organization_id=self.user.organization_id
         )

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/main.py

@@ -191,7 +191,6 @@ def run_agent_loop(
                     print(f"\nDumping memory contents:\n")
                     print(f"{letta_agent.agent_state.memory.compile()}")
                     print(f"{letta_agent.archival_memory.compile()}")
-                    print(f"{letta_agent.recall_memory.compile()}")
                     continue
 
                 elif user_input.lower() == "/model":

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/offline_memory_agent.py

@@ -150,11 +150,8 @@ class OfflineMemoryAgent(Agent):
         step_count = 0
 
         while counter < self.max_memory_rethinks:
-            # This is hacky but we need to do this for now
-            # TODO: REMOVE THIS
-            for m in next_input_message:
-                m.id = m._generate_id()
-
+            if counter > 0:
+                next_input_message = []
             kwargs["ms"] = ms
             kwargs["first_message"] = False
             step_response = self.inner_step(

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/orm/tool.py

@@ -30,6 +30,7 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     __table_args__ = (UniqueConstraint("name", "organization_id", name="uix_name_organization"),)
 
     name: Mapped[str] = mapped_column(doc="The display name of the tool.")
+    return_char_limit: Mapped[int] = mapped_column(nullable=True, doc="The maximum number of characters the tool can return.")
     description: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The description of the tool.")
     tags: Mapped[List] = mapped_column(JSON, doc="Metadata tags used to filter tools.")
     source_type: Mapped[ToolSourceType] = mapped_column(String, doc="The type of the source code.", default=ToolSourceType.json)
@@ -45,19 +46,16 @@ class Tool(SqlalchemyBase, OrganizationMixin):
 
 
 # Add event listener to update tool_name in ToolsAgents when Tool name changes
-@event.listens_for(Tool, 'before_update')
+@event.listens_for(Tool, "before_update")
 def update_tool_name_in_tools_agents(mapper, connection, target):
     """Update tool_name in ToolsAgents when Tool name changes."""
     state = target._sa_instance_state
-    history = state.get_history('name', passive=True)
+    history = state.get_history("name", passive=True)
     if not history.has_changes():
         return
-    
+
     # Get the new name and update all associated ToolsAgents records
     new_name = target.name
     from letta.orm.tools_agents import ToolsAgents
-    connection.execute(
-        ToolsAgents.__table__.update().where(
-            ToolsAgents.tool_id == target.id
-        ).values(tool_name=new_name)
-    )
+
+    connection.execute(ToolsAgents.__table__.update().where(ToolsAgents.tool_id == target.id).values(tool_name=new_name))

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/schemas/tool.py

@@ -2,6 +2,7 @@ from typing import Dict, List, Optional
 
 from pydantic import Field, model_validator
 
+from letta.constants import FUNCTION_RETURN_CHAR_LIMIT
 from letta.functions.functions import derive_openai_json_schema
 from letta.functions.helpers import (
     generate_composio_tool_wrapper,
@@ -41,6 +42,9 @@ class Tool(BaseTool):
     source_code: str = Field(..., description="The source code of the function.")
     json_schema: Optional[Dict] = Field(None, description="The 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.")
+
     # 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.")
@@ -91,6 +95,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)"
     )
+    return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
 
     @classmethod
     def from_composio(cls, action_name: str, api_key: Optional[str] = None) -> "ToolCreate":

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/server/rest_api/app.py

@@ -152,6 +152,10 @@ def create_application() -> "FastAPI":
 
         # Print the stack trace
         print(f"Stack trace: {exc.__traceback__}")
+        if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
+            import sentry_sdk
+
+            sentry_sdk.capture_exception(exc)
 
         return JSONResponse(
             status_code=500,

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/server/rest_api/routers/v1/agents.py

@@ -3,7 +3,16 @@ import warnings
 from datetime import datetime
 from typing import List, Optional, Union
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, status
+from fastapi import (
+    APIRouter,
+    BackgroundTasks,
+    Body,
+    Depends,
+    Header,
+    HTTPException,
+    Query,
+    status,
+)
 from fastapi.responses import JSONResponse, StreamingResponse
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
@@ -14,6 +23,7 @@ from letta.schemas.block import (  # , BlockLabelUpdate, BlockLimitUpdate
     CreateBlock,
 )
 from letta.schemas.enums import MessageStreamStatus
+from letta.schemas.job import Job, JobStatus, JobUpdate
 from letta.schemas.letta_message import (
     LegacyLettaMessage,
     LettaMessage,
@@ -32,6 +42,7 @@ from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
+from letta.schemas.user import User
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.utils import get_letta_server, sse_async_generator
 from letta.server.server import SyncServer
@@ -502,6 +513,94 @@ async def send_message_streaming(
     return result
 
 
+async def process_message_background(
+    job_id: str,
+    server: SyncServer,
+    actor: User,
+    agent_id: str,
+    user_id: str,
+    messages: list,
+    assistant_message_tool_name: str,
+    assistant_message_tool_kwarg: str,
+) -> None:
+    """Background task to process the message and update job status."""
+    try:
+        # TODO(matt) we should probably make this stream_steps and log each step as it progresses, so the job update GET can see the total steps so far + partial usage?
+        result = await send_message_to_agent(
+            server=server,
+            agent_id=agent_id,
+            user_id=user_id,
+            messages=messages,
+            stream_steps=False,  # NOTE(matt)
+            stream_tokens=False,
+            assistant_message_tool_name=assistant_message_tool_name,
+            assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+        )
+
+        # Update job status to completed
+        job_update = JobUpdate(
+            status=JobStatus.completed,
+            completed_at=datetime.utcnow(),
+            metadata_={"result": result.model_dump()},  # Store the result in metadata
+        )
+        server.job_manager.update_job_by_id(job_id=job_id, job_update=job_update, actor=actor)
+
+    except Exception as e:
+        # Update job status to failed
+        job_update = JobUpdate(
+            status=JobStatus.failed,
+            completed_at=datetime.utcnow(),
+            metadata_={"error": str(e)},
+        )
+        server.job_manager.update_job_by_id(job_id=job_id, job_update=job_update, actor=actor)
+        raise
+
+
+@router.post(
+    "/{agent_id}/messages/async",
+    response_model=Job,
+    operation_id="create_agent_message_async",
+)
+async def send_message_async(
+    agent_id: str,
+    background_tasks: BackgroundTasks,
+    server: SyncServer = Depends(get_letta_server),
+    request: LettaRequest = Body(...),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Asynchronously process a user message and return a job ID.
+    The actual processing happens in the background, and the status can be checked using the job ID.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    # Create a new job
+    job = Job(
+        user_id=actor.id,
+        status=JobStatus.created,
+        metadata_={
+            "job_type": "send_message_async",
+            "agent_id": agent_id,
+        },
+    )
+    job = server.job_manager.create_job(pydantic_job=job, actor=actor)
+
+    # Add the background task
+    background_tasks.add_task(
+        process_message_background,
+        job_id=job.id,
+        server=server,
+        actor=actor,
+        agent_id=agent_id,
+        user_id=actor.id,
+        messages=request.messages,
+        assistant_message_tool_name=request.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+    )
+
+    return job
+
+
 # TODO: move this into server.py?
 async def send_message_to_agent(
     server: SyncServer,

letta_nightly-0.6.2.dev20241210030252/letta/server/startup.sh

@@ -0,0 +1,49 @@
+#!/bin/sh
+set -e  # Exit on any error
+
+HOST="${HOST:-0.0.0.0}"
+PORT="${PORT:-8283}"
+
+# Function to wait for PostgreSQL to be ready
+wait_for_postgres() {
+    until pg_isready -U "${POSTGRES_USER:-letta}" -h localhost; do
+        echo "Waiting for PostgreSQL to be ready..."
+        sleep 2
+    done
+}
+
+# Check if we're configured for external Postgres
+if [ -n "$LETTA_PG_URI" ]; then
+    echo "External Postgres configuration detected, using $LETTA_PG_URI"
+else
+    echo "No external Postgres configuration detected, starting internal PostgreSQL..."
+    # Start PostgreSQL using the base image's entrypoint script
+    /usr/local/bin/docker-entrypoint.sh postgres &
+
+    # Wait for PostgreSQL to be ready
+    wait_for_postgres
+
+    # Set default connection URI for internal postgres
+    export LETTA_PG_URI="postgresql://${POSTGRES_USER:-letta}:${POSTGRES_PASSWORD:-letta}@localhost:5432/${POSTGRES_DB:-letta}"
+    echo "Using internal PostgreSQL at: $LETTA_PG_URI"
+fi
+
+# Attempt database migration
+echo "Attempting to migrate database..."
+if ! alembic upgrade head; then
+    echo "ERROR: Database migration failed!"
+    echo "Please check your database connection and try again."
+    echo "If the problem persists, check the logs for more details."
+    exit 1
+fi
+echo "Database migration completed successfully."
+
+# If ADE is enabled, add the --ade flag to the command
+CMD="letta server --host $HOST --port $PORT"
+if [ "${SECURE:-false}" = "true" ]; then
+    CMD="$CMD --secure"
+fi
+
+echo "Starting Letta server at http://$HOST:$PORT..."
+echo "Executing: $CMD"
+exec $CMD

{letta_nightly-0.6.1.dev20241209104258 → letta_nightly-0.6.2.dev20241210030252}/letta/utils.py

@@ -28,7 +28,6 @@ from letta.constants import (
     CLI_WARNING_PREFIX,
     CORE_MEMORY_HUMAN_CHAR_LIMIT,
     CORE_MEMORY_PERSONA_CHAR_LIMIT,
-    FUNCTION_RETURN_CHAR_LIMIT,
     LETTA_DIR,
     MAX_FILENAME_LENGTH,
     TOOL_CALL_ID_MAX_LEN,
@@ -906,8 +905,8 @@ def parse_json(string) -> dict:
         raise e
 
 
-def validate_function_response(function_response_string: any, strict: bool = False, truncate: bool = True) -> str:
-    """Check to make sure that a function used by Letta returned a valid response
+def validate_function_response(function_response_string: any, return_char_limit: int, strict: bool = False, truncate: bool = True) -> str:
+    """Check to make sure that a function used by Letta returned a valid response. Truncates to return_char_limit if necessary.
 
     Responses need to be strings (or None) that fall under a certain text count limit.
     """
@@ -943,11 +942,11 @@ def validate_function_response(function_response_string: any, strict: bool = Fal
 
     # Now check the length and make sure it doesn't go over the limit
     # TODO we should change this to a max token limit that's variable based on tokens remaining (or context-window)
-    if truncate and len(function_response_string) > FUNCTION_RETURN_CHAR_LIMIT:
+    if truncate and len(function_response_string) > return_char_limit:
         print(
-            f"{CLI_WARNING_PREFIX}function return was over limit ({len(function_response_string)} > {FUNCTION_RETURN_CHAR_LIMIT}) and was truncated"
+            f"{CLI_WARNING_PREFIX}function return was over limit ({len(function_response_string)} > {return_char_limit}) and was truncated"
         )
-        function_response_string = f"{function_response_string[:FUNCTION_RETURN_CHAR_LIMIT]}... [NOTE: function output was truncated since it exceeded the character limit ({len(function_response_string)} > {FUNCTION_RETURN_CHAR_LIMIT})]"
+        function_response_string = f"{function_response_string[:return_char_limit]}... [NOTE: function output was truncated since it exceeded the character limit ({len(function_response_string)} > {return_char_limit})]"
 
     return function_response_string