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

letta/server/rest_api/routers/v1/agents.py

@@ -17,14 +17,13 @@ from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.memory import ContextWindowOverview, CreateArchivalMemory, Memory
 from letta.schemas.message import Message, MessageUpdate
-from letta.schemas.passage import Passage
+from letta.schemas.passage import Passage, PassageUpdate
 from letta.schemas.run import Run
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
 from letta.schemas.user import User
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
-from letta.tracing import trace_method
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
 
@@ -273,14 +272,14 @@ def retrieve_agent_memory(
 
 
 @router.get("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="retrieve_core_memory_block")
-def retrieve_core_memory_block(
+def retrieve_block(
     agent_id: str,
     block_label: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
-    Retrieve a memory block from an agent.
+    Retrieve a core memory block from an agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
@@ -291,13 +290,13 @@ def retrieve_core_memory_block(
 
 
 @router.get("/{agent_id}/core-memory/blocks", response_model=List[Block], operation_id="list_core_memory_blocks")
-def list_core_memory_blocks(
+def list_blocks(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
-    Retrieve the memory blocks of a specific agent.
+    Retrieve the core memory blocks of a specific agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     try:
@@ -308,7 +307,7 @@ def list_core_memory_blocks(
 
 
 @router.patch("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="modify_core_memory_block")
-def modify_core_memory_block(
+def modify_block(
     agent_id: str,
     block_label: str,
     block_update: BlockUpdate = Body(...),
@@ -316,7 +315,7 @@ def modify_core_memory_block(
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
-    Updates a memory block of an agent.
+    Updates a core memory block of an agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
@@ -330,35 +329,35 @@ def modify_core_memory_block(
 
 
 @router.patch("/{agent_id}/core-memory/blocks/attach/{block_id}", response_model=AgentState, operation_id="attach_core_memory_block")
-def attach_core_memory_block(
+def attach_block(
     agent_id: str,
     block_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
-    Attach a block to an agent.
+    Attach a core memoryblock to an agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     return server.agent_manager.attach_block(agent_id=agent_id, block_id=block_id, actor=actor)
 
 
 @router.patch("/{agent_id}/core-memory/blocks/detach/{block_id}", response_model=AgentState, operation_id="detach_core_memory_block")
-def detach_core_memory_block(
+def detach_block(
     agent_id: str,
     block_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
-    Detach a block from an agent.
+    Detach a core memory block from an agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     return server.agent_manager.detach_block(agent_id=agent_id, block_id=block_id, actor=actor)
 
 
-@router.get("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="list_archival_memory")
-def list_archival_memory(
+@router.get("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="list_passages")
+def list_passages(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     after: Optional[int] = Query(None, description="Unique ID of the memory to start the query range at."),
@@ -380,8 +379,8 @@ def list_archival_memory(
     )
 
 
-@router.post("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="create_archival_memory")
-def create_archival_memory(
+@router.post("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="create_passage")
+def create_passage(
     agent_id: str,
     request: CreateArchivalMemory = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
@@ -395,10 +394,25 @@ def create_archival_memory(
     return server.insert_archival_memory(agent_id=agent_id, memory_contents=request.text, actor=actor)
 
 
+@router.patch("/{agent_id}/archival-memory/{memory_id}", response_model=List[Passage], operation_id="modify_passage")
+def modify_passage(
+    agent_id: str,
+    memory_id: str,
+    passage: PassageUpdate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Modify a memory in the agent's archival memory store.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    return server.modify_archival_memory(agent_id=agent_id, memory_id=memory_id, passage=passage, actor=actor)
+
+
 # TODO(ethan): query or path parameter for memory_id?
 # @router.delete("/{agent_id}/archival")
-@router.delete("/{agent_id}/archival-memory/{memory_id}", response_model=None, operation_id="delete_archival_memory")
-def delete_archival_memory(
+@router.delete("/{agent_id}/archival-memory/{memory_id}", response_model=None, operation_id="delete_passage")
+def delete_passage(
     agent_id: str,
     memory_id: str,
     # memory_id: str = Query(..., description="Unique ID of the memory to be deleted."),
@@ -471,7 +485,6 @@ def modify_message(
     response_model=LettaResponse,
     operation_id="send_message",
 )
-@trace_method("POST /v1/agents/{agent_id}/messages")
 async def send_message(
     agent_id: str,
     server: SyncServer = Depends(get_letta_server),
@@ -510,7 +523,6 @@ async def send_message(
         }
     },
 )
-@trace_method("POST /v1/agents/{agent_id}/messages/stream")
 async def send_message_streaming(
     agent_id: str,
     server: SyncServer = Depends(get_letta_server),
@@ -586,7 +598,6 @@ async def process_message_background(
     response_model=Run,
     operation_id="create_agent_message_async",
 )
-@trace_method("POST /v1/agents/{agent_id}/messages/async")
 async def send_message_async(
     agent_id: str,
     background_tasks: BackgroundTasks,

letta/server/rest_api/routers/v1/identities.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, List, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
-from letta.orm.errors import NoResultFound
+from letta.orm.errors import NoResultFound, UniqueConstraintViolationError
 from letta.schemas.identity import Identity, IdentityCreate, IdentityType, IdentityUpdate
 from letta.server.rest_api.utils import get_letta_server
 
@@ -72,6 +72,14 @@ def create_identity(
         return server.identity_manager.create_identity(identity=identity, actor=actor)
     except HTTPException:
         raise
+    except UniqueConstraintViolationError:
+        if identity.project_id:
+            raise HTTPException(
+                status_code=400,
+                detail=f"An identity with identifier key {identity.identifier_key} already exists for project {identity.project_id}",
+            )
+        else:
+            raise HTTPException(status_code=400, detail=f"An identity with identifier key {identity.identifier_key} already exists")
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
 

letta/server/rest_api/routers/v1/runs.py

@@ -9,6 +9,7 @@ from letta.schemas.enums import JobStatus, MessageRole
 from letta.schemas.letta_message import LettaMessageUnion
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.run import Run
+from letta.schemas.step import Step
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 
@@ -137,6 +138,54 @@ def retrieve_run_usage(
         raise HTTPException(status_code=404, detail=f"Run '{run_id}' not found")
 
 
+@router.get(
+    "/{run_id}/steps",
+    response_model=List[Step],
+    operation_id="list_run_steps",
+)
+async def list_run_steps(
+    run_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    before: Optional[str] = Query(None, description="Cursor for pagination"),
+    after: Optional[str] = Query(None, description="Cursor for pagination"),
+    limit: Optional[int] = Query(100, description="Maximum number of messages to return"),
+    order: str = Query(
+        "desc", description="Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order."
+    ),
+):
+    """
+    Get messages associated with a run with filtering options.
+
+    Args:
+        run_id: ID of the run
+        before: A cursor for use in pagination. `before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.
+        after: A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
+        limit: Maximum number of steps to return
+        order: Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
+
+    Returns:
+        A list of steps associated with the run.
+    """
+    if order not in ["asc", "desc"]:
+        raise HTTPException(status_code=400, detail="Order must be 'asc' or 'desc'")
+
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+
+    try:
+        steps = server.job_manager.get_job_steps(
+            job_id=run_id,
+            actor=actor,
+            limit=limit,
+            before=before,
+            after=after,
+            ascending=(order == "asc"),
+        )
+        return steps
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
 @router.delete("/{run_id}", response_model=Run, operation_id="delete_run")
 def delete_run(
     run_id: str,

letta/server/rest_api/routers/v1/tools.py

@@ -190,6 +190,7 @@ def run_tool_from_source(
             tool_args=request.args,
             tool_env_vars=request.env_vars,
             tool_name=request.name,
+            tool_args_json_schema=request.args_json_schema,
             actor=actor,
         )
     except LettaToolCreateError as e:

letta/server/rest_api/routers/v1/voice.py

@@ -1,42 +1,15 @@
-import json
-import uuid
 from typing import TYPE_CHECKING, Optional
 
 import httpx
 import openai
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 from fastapi.responses import StreamingResponse
-from openai.types.chat.chat_completion_chunk import ChatCompletionChunk, Choice, ChoiceDelta
 from openai.types.chat.completion_create_params import CompletionCreateParams
-from starlette.concurrency import run_in_threadpool
 
-from letta.constants import LETTA_TOOL_SET, NON_USER_MSG_PREFIX, PRE_EXECUTION_MESSAGE_ARG
-from letta.helpers.tool_execution_helper import (
-    add_pre_execution_message,
-    enable_strict_mode,
-    execute_external_tool,
-    remove_request_heartbeat,
-)
+from letta.agents.low_latency_agent import LowLatencyAgent
 from letta.log import get_logger
-from letta.orm.enums import ToolType
-from letta.schemas.openai.chat_completion_request import (
-    AssistantMessage,
-    ChatCompletionRequest,
-    Tool,
-    ToolCall,
-    ToolCallFunction,
-    ToolMessage,
-    UserMessage,
-)
-from letta.server.rest_api.optimistic_json_parser import OptimisticJSONParser
-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,
-    get_letta_server,
-    get_messages_from_completion_request,
-)
+from letta.schemas.openai.chat_completions import UserMessage
+from letta.server.rest_api.utils import get_letta_server, get_messages_from_completion_request
 from letta.settings import model_settings
 
 if TYPE_CHECKING:
@@ -72,42 +45,10 @@ async def create_voice_chat_completions(
     if agent_id is None:
         raise HTTPException(status_code=400, detail="Must pass agent_id in the 'user' field")
 
-    agent_state = server.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
-    if agent_state.llm_config.model_endpoint_type != "openai":
-        raise HTTPException(status_code=400, detail="Only OpenAI models are supported by this endpoint.")
-
-    # Convert Letta messages to OpenAI messages
-    in_context_messages = server.message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=actor)
-    openai_messages = convert_letta_messages_to_openai(in_context_messages)
-
-    # Also parse user input from completion_request and append
-    input_message = get_messages_from_completion_request(completion_request)[-1]
-    openai_messages.append(input_message)
+    # Also parse the user's new input
+    input_message = UserMessage(**get_messages_from_completion_request(completion_request)[-1])
 
-    # Tools we allow this agent to call
-    tools = [t for t in agent_state.tools if t.name not in LETTA_TOOL_SET and t.tool_type in {ToolType.EXTERNAL_COMPOSIO, ToolType.CUSTOM}]
-
-    # Initial request
-    openai_request = ChatCompletionRequest(
-        model=agent_state.llm_config.model,
-        messages=openai_messages,
-        # TODO: This nested thing here is so ugly, need to refactor
-        tools=(
-            [
-                Tool(type="function", function=enable_strict_mode(add_pre_execution_message(remove_request_heartbeat(t.json_schema))))
-                for t in tools
-            ]
-            if tools
-            else None
-        ),
-        tool_choice="auto",
-        user=user_id,
-        max_completion_tokens=agent_state.llm_config.max_tokens,
-        temperature=agent_state.llm_config.temperature,
-        stream=True,
-    )
-
-    # Create the OpenAI async client
+    # Create OpenAI async client
     client = openai.AsyncClient(
         api_key=model_settings.openai_api_key,
         max_retries=0,
@@ -122,194 +63,17 @@ async def create_voice_chat_completions(
         ),
     )
 
-    # The messages we want to persist to the Letta agent
-    user_message = create_user_message(input_message=input_message, agent_id=agent_id, actor=actor)
-    message_db_queue = [user_message]
-
-    async def event_stream():
-        """
-        A function-calling loop:
-          - We stream partial tokens.
-          - If we detect a tool call (finish_reason="tool_calls"), we parse it,
-            add two messages to the conversation:
-              (a) assistant message with tool_calls referencing the same ID
-              (b) a tool message referencing that ID, containing the tool result.
-          - Re-invoke the OpenAI request with updated conversation, streaming again.
-          - End when finish_reason="stop" or no more tool calls.
-        """
-
-        # We'll keep updating this conversation in a loop
-        conversation = openai_messages[:]
-
-        while True:
-            # Make the streaming request to OpenAI
-            stream = await client.chat.completions.create(**openai_request.model_dump(exclude_unset=True))
-
-            content_buffer = []
-            tool_call_name = None
-            tool_call_args_str = ""
-            tool_call_id = None
-            tool_call_happened = False
-            finish_reason_stop = False
-            optimistic_json_parser = OptimisticJSONParser(strict=True)
-            current_parsed_json_result = {}
-
-            async with stream:
-                async for chunk in stream:
-                    choice = chunk.choices[0]
-                    delta = choice.delta
-                    finish_reason = choice.finish_reason  # "tool_calls", "stop", or None
-
-                    if delta.content:
-                        content_buffer.append(delta.content)
-                        yield f"data: {chunk.model_dump_json()}\n\n"
-
-                    # CASE B: Partial tool call info
-                    if delta.tool_calls:
-                        # Typically there's only one in delta.tool_calls
-                        tc = delta.tool_calls[0]
-                        if tc.function.name:
-                            tool_call_name = tc.function.name
-                        if tc.function.arguments:
-                            tool_call_args_str += tc.function.arguments
-
-                            # See if we can stream out the pre-execution message
-                            parsed_args = optimistic_json_parser.parse(tool_call_args_str)
-                            if parsed_args.get(
-                                PRE_EXECUTION_MESSAGE_ARG
-                            ) and current_parsed_json_result.get(  # Ensure key exists and is not None/empty
-                                PRE_EXECUTION_MESSAGE_ARG
-                            ) != parsed_args.get(
-                                PRE_EXECUTION_MESSAGE_ARG
-                            ):
-                                # Only stream if there's something new to stream
-                                # We do this way to avoid hanging JSON at the end of the stream, e.g. '}'
-                                if parsed_args != current_parsed_json_result:
-                                    current_parsed_json_result = parsed_args
-                                    synthetic_chunk = ChatCompletionChunk(
-                                        id=chunk.id,
-                                        object=chunk.object,
-                                        created=chunk.created,
-                                        model=chunk.model,
-                                        choices=[
-                                            Choice(
-                                                index=choice.index,
-                                                delta=ChoiceDelta(content=tc.function.arguments, role="assistant"),
-                                                finish_reason=None,
-                                            )
-                                        ],
-                                    )
-
-                                    yield f"data: {synthetic_chunk.model_dump_json()}\n\n"
-
-                        # We might generate a unique ID for the tool call
-                        if tc.id:
-                            tool_call_id = tc.id
-
-                    # Check finish_reason
-                    if finish_reason == "tool_calls":
-                        tool_call_happened = True
-                        break
-                    elif finish_reason == "stop":
-                        finish_reason_stop = True
-                        break
-
-            if content_buffer:
-                # We treat that partial text as an assistant message
-                content = "".join(content_buffer)
-                conversation.append({"role": "assistant", "content": content})
-
-                # Create an assistant message here to persist later
-                assistant_messages = create_assistant_messages_from_openai_response(
-                    response_text=content, agent_id=agent_id, model=agent_state.llm_config.model, actor=actor
-                )
-                message_db_queue.extend(assistant_messages)
-
-            if tool_call_happened:
-                # Parse the tool call arguments
-                try:
-                    tool_args = json.loads(tool_call_args_str)
-                except json.JSONDecodeError:
-                    tool_args = {}
-
-                if not tool_call_id:
-                    # If no tool_call_id given by the model, generate one
-                    tool_call_id = f"call_{uuid.uuid4().hex[:8]}"
-
-                # 1) Insert the "assistant" message with the tool_calls field
-                #    referencing the same tool_call_id
-                assistant_tool_call_msg = AssistantMessage(
-                    content=None,
-                    tool_calls=[ToolCall(id=tool_call_id, function=ToolCallFunction(name=tool_call_name, arguments=tool_call_args_str))],
-                )
-
-                conversation.append(assistant_tool_call_msg.model_dump())
-
-                # 2) Execute the tool
-                target_tool = next((x for x in tools if x.name == tool_call_name), None)
-                if not target_tool:
-                    # Tool not found, handle error
-                    yield f"data: {json.dumps({'error': 'Tool not found', 'tool': tool_call_name})}\n\n"
-                    break
-
-                try:
-                    tool_result, _ = execute_external_tool(
-                        agent_state=agent_state,
-                        function_name=tool_call_name,
-                        function_args=tool_args,
-                        target_letta_tool=target_tool,
-                        actor=actor,
-                        allow_agent_state_modifications=False,
-                    )
-                    function_call_success = True
-                except Exception as e:
-                    tool_result = f"Failed to call tool. Error: {e}"
-                    function_call_success = False
-
-                # 3) Insert the "tool" message referencing the same tool_call_id
-                tool_message = ToolMessage(content=json.dumps({"result": tool_result}), tool_call_id=tool_call_id)
-
-                conversation.append(tool_message.model_dump())
-
-                # 4) Add a user message prompting the tool call result summarization
-                heartbeat_user_message = UserMessage(
-                    content=f"{NON_USER_MSG_PREFIX} Tool finished executing. Summarize the result for the user.",
-                )
-                conversation.append(heartbeat_user_message.model_dump())
-
-                # Now, re-invoke OpenAI with the updated conversation
-                openai_request.messages = conversation
-
-                # Create a tool call message and append to message_db_queue
-                tool_call_messages = create_tool_call_messages_from_openai_response(
-                    agent_id=agent_state.id,
-                    model=agent_state.llm_config.model,
-                    function_name=tool_call_name,
-                    function_arguments=tool_args,
-                    tool_call_id=tool_call_id,
-                    function_call_success=function_call_success,
-                    function_response=tool_result,
-                    actor=actor,
-                    add_heartbeat_request_system_message=True,
-                )
-                message_db_queue.extend(tool_call_messages)
-
-                continue  # Start the while loop again
-
-            if finish_reason_stop:
-                break
-
-            # If we reach here, no tool call, no "stop", but we've ended streaming
-            # Possibly a model error or some other finish reason. We'll just end.
-            break
-
-        await run_in_threadpool(
-            server.agent_manager.append_to_in_context_messages,
-            message_db_queue,
-            agent_id=agent_id,
-            actor=actor,
-        )
-
-        yield "data: [DONE]\n\n"
+    # Instantiate our LowLatencyAgent
+    agent = LowLatencyAgent(
+        agent_id=agent_id,
+        openai_client=client,
+        message_manager=server.message_manager,
+        agent_manager=server.agent_manager,
+        block_manager=server.block_manager,
+        actor=actor,
+        message_buffer_limit=10,
+        message_buffer_min=4,
+    )
 
-    return StreamingResponse(event_stream(), media_type="text/event-stream")
+    # Return the streaming generator
+    return StreamingResponse(agent.step_stream(input_message=input_message), media_type="text/event-stream")

letta/server/rest_api/utils.py

@@ -13,7 +13,7 @@ from openai.types.chat.chat_completion_message_tool_call import Function as Open
 from openai.types.chat.completion_create_params import CompletionCreateParams
 from pydantic import BaseModel
 
-from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, REQ_HEARTBEAT_MESSAGE
+from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, FUNC_FAILED_HEARTBEAT_MESSAGE, REQ_HEARTBEAT_MESSAGE
 from letta.errors import ContextWindowExceededError, RateLimitExceededError
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
@@ -216,9 +216,10 @@ def create_tool_call_messages_from_openai_response(
     messages.append(tool_message)
 
     if add_heartbeat_request_system_message:
+        text_content = REQ_HEARTBEAT_MESSAGE if function_call_success else FUNC_FAILED_HEARTBEAT_MESSAGE
         heartbeat_system_message = Message(
             role=MessageRole.user,
-            content=[TextContent(text=get_heartbeat(REQ_HEARTBEAT_MESSAGE))],
+            content=[TextContent(text=get_heartbeat(text_content))],
             organization_id=actor.organization_id,
             agent_id=agent_id,
             model=model,

letta/server/server.py

@@ -6,7 +6,7 @@ import traceback
 import warnings
 from abc import abstractmethod
 from datetime import datetime
-from typing import Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from composio.client import Composio
 from composio.client.collections import ActionModel, AppModel
@@ -17,7 +17,6 @@ import letta.constants as constants
 import letta.server.utils as server_utils
 import letta.system as system
 from letta.agent import Agent, save_agent
-from letta.chat_only_agent import ChatOnlyAgent
 from letta.config import LettaConfig
 from letta.data_sources.connectors import DataConnector, load_data
 from letta.helpers.datetime_helpers import get_utc_time
@@ -43,7 +42,7 @@ from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, ContextWindowOverview, Memory, RecallMemorySummary
 from letta.schemas.message import Message, MessageCreate, MessageRole, MessageUpdate, TextContent
 from letta.schemas.organization import Organization
-from letta.schemas.passage import Passage
+from letta.schemas.passage import Passage, PassageUpdate
 from letta.schemas.providers import (
     AnthropicBedrockProvider,
     AnthropicProvider,
@@ -326,8 +325,6 @@ class SyncServer(Server):
                 agent = Agent(agent_state=agent_state, interface=interface, user=actor)
             elif agent_state.agent_type == AgentType.offline_memory_agent:
                 agent = OfflineMemoryAgent(agent_state=agent_state, interface=interface, user=actor)
-            elif agent_state.agent_type == AgentType.chat_only_agent:
-                agent = ChatOnlyAgent(agent_state=agent_state, interface=interface, user=actor)
             else:
                 raise ValueError(f"Invalid agent type {agent_state.agent_type}")
 
@@ -770,6 +767,11 @@ class SyncServer(Server):
 
         return passages
 
+    def modify_archival_memory(self, agent_id: str, memory_id: str, passage: PassageUpdate, actor: User) -> List[Passage]:
+        passage = Passage(**passage.model_dump(exclude_unset=True, exclude_none=True))
+        passages = self.passage_manager.update_passage_by_id(passage_id=memory_id, passage=passage, actor=actor)
+        return passages
+
     def delete_archival_memory(self, memory_id: str, actor: User):
         # TODO check if it exists first, and throw error if not
         # TODO: @mindy make this return the deleted passage instead
@@ -978,6 +980,10 @@ class SyncServer(Server):
                 warnings.warn(f"An error occurred while listing LLM models for provider {provider}: {e}")
 
         llm_models.extend(self.get_local_llm_configs())
+
+        # respect global maximum
+        for llm_config in llm_models:
+            llm_config.context_window = min(llm_config.context_window, model_settings.global_max_context_window_limit)
         return llm_models
 
     def list_embedding_models(self) -> List[EmbeddingConfig]:
@@ -1023,7 +1029,7 @@ class SyncServer(Server):
                 raise ValueError(f"Context window limit ({context_window_limit}) is greater than maximum of ({llm_config.context_window})")
             llm_config.context_window = context_window_limit
         else:
-            llm_config.context_window = min(llm_config.context_window, constants.DEFAULT_CONTEXT_WINDOW_SIZE)
+            llm_config.context_window = min(llm_config.context_window, model_settings.global_max_context_window_limit)
 
         return llm_config
 
@@ -1098,6 +1104,7 @@ class SyncServer(Server):
         tool_env_vars: Optional[Dict[str, str]] = None,
         tool_source_type: Optional[str] = None,
         tool_name: Optional[str] = None,
+        tool_args_json_schema: Optional[Dict[str, Any]] = None,
     ) -> ToolReturnMessage:
         """Run a tool from source code"""
         if tool_source_type is not None and tool_source_type != "python":
@@ -1107,6 +1114,7 @@ class SyncServer(Server):
         tool = Tool(
             name=tool_name,
             source_code=tool_source,
+            args_json_schema=tool_args_json_schema,
         )
         assert tool.name is not None, "Failed to create tool object"
 
@@ -1164,7 +1172,7 @@ class SyncServer(Server):
         actions = self.get_composio_client(api_key=api_key).actions.get(apps=[composio_app_name])
         return actions
 
-    @trace_method("Send Message")
+    @trace_method
     async def send_message_to_agent(
         self,
         agent_id: str,