letta-nightly 0.6.53.dev20250418104238__py3-none-any.whl → 0.6.54.dev20250419194309__py3-none-any.whl

letta/functions/function_sets/base.py

@@ -1,6 +1,7 @@
 from typing import Optional
 
 from letta.agent import Agent
+from letta.constants import CORE_MEMORY_LINE_NUMBER_WARNING
 
 
 def send_message(self: "Agent", message: str) -> Optional[str]:
@@ -195,40 +196,186 @@ def finish_rethinking_memory(agent_state: "AgentState") -> None:  # type: ignore
     return None
 
 
-def view_core_memory_with_line_numbers(agent_state: "AgentState", target_block_label: str) -> None:  # type: ignore
+## Attempted v2 of sleep-time function set, meant to work better across all types
+
+SNIPPET_LINES: int = 4
+
+
+# Based off of: https://github.com/anthropics/anthropic-quickstarts/blob/main/computer-use-demo/computer_use_demo/tools/edit.py?ref=musings.yasyf.com#L154
+def memory_replace(agent_state: "AgentState", label: str, old_str: str, new_str: Optional[str] = None) -> str:  # type: ignore
     """
-    View the contents of core memory in editor mode with line numbers. Called before `core_memory_insert` to see line numbers of memory block.
+    The memory_replace command allows you to replace a specific string in a memory block with a new string. This is used for making precise edits.
 
     Args:
-        target_block_label (str): The name of the block to view.
+        label (str): Section of the memory to be edited, identified by its label.
+        old_str (str): The text to replace (must match exactly, including whitespace and indentation).
+        new_str (Optional[str]): The new text to insert in place of the old text. Omit this argument to delete the old_str.
 
     Returns:
-        None: None is always returned as this function does not produce a response.
+        str: The success message
     """
-    return None
+    import re
+
+    if bool(re.search(r"\nLine \d+: ", old_str)):
+        raise ValueError(
+            "old_str contains a line number prefix, which is not allowed. Do not include line numbers when calling memory tools (line numbers are for display purposes only)."
+        )
+    if CORE_MEMORY_LINE_NUMBER_WARNING in old_str:
+        raise ValueError(
+            "old_str contains a line number warning, which is not allowed. Do not include line number information when calling memory tools (line numbers are for display purposes only)."
+        )
+    if bool(re.search(r"\nLine \d+: ", new_str)):
+        raise ValueError(
+            "new_str contains a line number prefix, which is not allowed. Do not include line numbers when calling memory tools (line numbers are for display purposes only)."
+        )
+
+    old_str = str(old_str).expandtabs()
+    new_str = str(new_str).expandtabs()
+    current_value = str(agent_state.memory.get_block(label).value).expandtabs()
+
+    # Check if old_str is unique in the block
+    occurences = current_value.count(old_str)
+    if occurences == 0:
+        raise ValueError(f"No replacement was performed, old_str `{old_str}` did not appear verbatim in memory block with label `{label}`.")
+    elif occurences > 1:
+        content_value_lines = current_value.split("\n")
+        lines = [idx + 1 for idx, line in enumerate(content_value_lines) if old_str in line]
+        raise ValueError(
+            f"No replacement was performed. Multiple occurrences of old_str `{old_str}` in lines {lines}. Please ensure it is unique."
+        )
+
+    # Replace old_str with new_str
+    new_value = current_value.replace(str(old_str), str(new_str))
+
+    # Write the new content to the block
+    agent_state.memory.update_block_value(label=label, value=new_value)
 
+    # Create a snippet of the edited section
+    SNIPPET_LINES = 3
+    replacement_line = current_value.split(old_str)[0].count("\n")
+    start_line = max(0, replacement_line - SNIPPET_LINES)
+    end_line = replacement_line + SNIPPET_LINES + new_str.count("\n")
+    snippet = "\n".join(new_value.split("\n")[start_line : end_line + 1])
 
-def core_memory_insert(agent_state: "AgentState", target_block_label: str, new_memory: str, line_number: Optional[int] = None, replace: bool = False) -> None:  # type: ignore
+    # Prepare the success message
+    success_msg = f"The core memory block with label `{label}` has been edited. "
+    # success_msg += self._make_output(
+    #     snippet, f"a snippet of {path}", start_line + 1
+    # )
+    # success_msg += f"A snippet of core memory block `{label}`:\n{snippet}\n"
+    success_msg += "Review the changes and make sure they are as expected (correct indentation, no duplicate lines, etc). Edit the memory block again if necessary."
+
+    # return None
+    return success_msg
+
+
+def memory_insert(agent_state: "AgentState", label: str, new_str: str, insert_line: int = -1) -> Optional[str]:  # type: ignore
     """
-    Insert new memory content into a core memory block at a specific line number. Call `view_core_memory_with_line_numbers` to see line numbers of the memory block before using this tool.
+    The memory_insert command allows you to insert text at a specific location in a memory block.
 
     Args:
-        target_block_label (str): The name of the block to write to.
-        new_memory (str): The new memory content to insert.
-        line_number (Optional[int]): Line number to insert content into, 0 indexed (None for end of file).
-        replace (bool): Whether to overwrite the content at the specified line number.
+        label (str): Section of the memory to be edited, identified by its label.
+        new_str (str): The text to insert.
+        insert_line (int): The line number after which to insert the text (0 for beginning of file). Defaults to -1 (end of the file).
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    import re
+
+    if bool(re.search(r"\nLine \d+: ", new_str)):
+        raise ValueError(
+            "new_str contains a line number prefix, which is not allowed. Do not include line numbers when calling memory tools (line numbers are for display purposes only)."
+        )
+    if CORE_MEMORY_LINE_NUMBER_WARNING in new_str:
+        raise ValueError(
+            "new_str contains a line number warning, which is not allowed. Do not include line number information when calling memory tools (line numbers are for display purposes only)."
+        )
+
+    current_value = str(agent_state.memory.get_block(label).value).expandtabs()
+    new_str = str(new_str).expandtabs()
+    current_value_lines = current_value.split("\n")
+    n_lines = len(current_value_lines)
+
+    # Check if we're in range, from 0 (pre-line), to 1 (first line), to n_lines (last line)
+    if insert_line < 0 or insert_line > n_lines:
+        raise ValueError(
+            f"Invalid `insert_line` parameter: {insert_line}. It should be within the range of lines of the memory block: {[0, n_lines]}, or -1 to append to the end of the memory block."
+        )
+
+    # Insert the new string as a line
+    new_str_lines = new_str.split("\n")
+    new_value_lines = current_value_lines[:insert_line] + new_str_lines + current_value_lines[insert_line:]
+    snippet_lines = (
+        current_value_lines[max(0, insert_line - SNIPPET_LINES) : insert_line]
+        + new_str_lines
+        + current_value_lines[insert_line : insert_line + SNIPPET_LINES]
+    )
+
+    # Collate into the new value to update
+    new_value = "\n".join(new_value_lines)
+    snippet = "\n".join(snippet_lines)
+
+    # Write into the block
+    agent_state.memory.update_block_value(label=label, value=new_value)
+
+    # Prepare the success message
+    success_msg = f"The core memory block with label `{label}` has been edited. "
+    # success_msg += self._make_output(
+    #     snippet,
+    #     "a snippet of the edited file",
+    #     max(1, insert_line - SNIPPET_LINES + 1),
+    # )
+    # success_msg += f"A snippet of core memory block `{label}`:\n{snippet}\n"
+    success_msg += "Review the changes and make sure they are as expected (correct indentation, no duplicate lines, etc). Edit the memory block again if necessary."
+
+    return success_msg
+
+
+def memory_rethink(agent_state: "AgentState", label: str, new_memory: str) -> None:
+    """
+    The memory_rethink command allows you to completely rewrite the contents of a memory block. Use this tool to make large sweeping changes (e.g. when you want to condense or reorganize the memory blocks), do NOT use this tool to make small precise edits (e.g. add or remove a line, replace a specific string, etc).
+
+    Args:
+        label (str): The memory block to be rewritten, identified by its label.
+        new_memory (str): The new memory contents with information integrated from existing memory blocks and the conversation context.
 
     Returns:
         None: None is always returned as this function does not produce a response.
     """
-    current_value = str(agent_state.memory.get_block(target_block_label).value)
-    current_value_list = current_value.split("\n")
-    if line_number is None:
-        line_number = len(current_value_list)
-    if replace:
-        current_value_list[line_number - 1] = new_memory
-    else:
-        current_value_list.insert(line_number, new_memory)
-    new_value = "\n".join(current_value_list)
-    agent_state.memory.update_block_value(label=target_block_label, value=new_value)
+    import re
+
+    if bool(re.search(r"\nLine \d+: ", new_memory)):
+        raise ValueError(
+            "new_memory contains a line number prefix, which is not allowed. Do not include line numbers when calling memory tools (line numbers are for display purposes only)."
+        )
+    if CORE_MEMORY_LINE_NUMBER_WARNING in new_memory:
+        raise ValueError(
+            "new_memory contains a line number warning, which is not allowed. Do not include line number information when calling memory tools (line numbers are for display purposes only)."
+        )
+
+    if agent_state.memory.get_block(label) is None:
+        agent_state.memory.create_block(label=label, value=new_memory)
+
+    agent_state.memory.update_block_value(label=label, value=new_memory)
+
+    # Prepare the success message
+    success_msg = f"The core memory block with label `{label}` has been edited. "
+    # success_msg += self._make_output(
+    #     snippet, f"a snippet of {path}", start_line + 1
+    # )
+    # success_msg += f"A snippet of core memory block `{label}`:\n{snippet}\n"
+    success_msg += "Review the changes and make sure they are as expected (correct indentation, no duplicate lines, etc). Edit the memory block again if necessary."
+
+    # return None
+    return success_msg
+
+
+def memory_finish_edits(agent_state: "AgentState") -> None:  # type: ignore
+    """
+    Call the memory_finish_edits command when you are finished making edits (integrating all new information) into the memory blocks. This function is called when the agent is done rethinking the memory.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
     return None

letta/groups/sleeptime_multi_agent.py

@@ -1,6 +1,6 @@
 import asyncio
 import threading
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import List, Optional
 
 from letta.agent import Agent, AgentState
@@ -154,7 +154,7 @@ class SleeptimeMultiAgent(Agent):
             )
             job_update = JobUpdate(
                 status=JobStatus.completed,
-                completed_at=datetime.utcnow(),
+                completed_at=datetime.now(timezone.utc),
                 metadata={
                     "result": result.model_dump(mode="json"),
                     "agent_id": participant_agent.agent_state.id,
@@ -165,7 +165,7 @@ class SleeptimeMultiAgent(Agent):
         except Exception as e:
             job_update = JobUpdate(
                 status=JobStatus.failed,
-                completed_at=datetime.utcnow(),
+                completed_at=datetime.now(timezone.utc),
                 metadata={"error": str(e)},
             )
             self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.user)

letta/helpers/converters.py

@@ -154,7 +154,7 @@ def deserialize_tool_calls(data: Optional[List[Dict]]) -> List[OpenAIToolCall]:
     calls = []
     for item in data:
         func_data = item.pop("function", None)
-        tool_call_function = OpenAIFunction(**func_data) if func_data else None
+        tool_call_function = OpenAIFunction(**func_data)
         calls.append(OpenAIToolCall(function=tool_call_function, **item))
 
     return calls

letta/helpers/message_helper.py

@@ -39,4 +39,5 @@ def prepare_input_message_create(
         tool_calls=None,  # irrelevant
         tool_call_id=None,
         otid=message.otid,
+        sender_id=message.sender_id,
     )

letta/jobs/llm_batch_job_polling.py

@@ -2,11 +2,14 @@ import asyncio
 import datetime
 from typing import List
 
+from letta.agents.letta_agent_batch import LettaAgentBatch
 from letta.jobs.helpers import map_anthropic_batch_job_status_to_job_status, map_anthropic_individual_batch_item_status_to_job_status
-from letta.jobs.types import BatchId, BatchPollingResult, ItemUpdateInfo
+from letta.jobs.types import BatchPollingResult, ItemUpdateInfo
 from letta.log import get_logger
 from letta.schemas.enums import JobStatus, ProviderType
+from letta.schemas.letta_response import LettaBatchResponse
 from letta.schemas.llm_batch_job import LLMBatchJob
+from letta.schemas.user import User
 from letta.server.server import SyncServer
 
 logger = get_logger(__name__)
@@ -49,14 +52,14 @@ async def fetch_batch_status(server: SyncServer, batch_job: LLMBatchJob) -> Batc
         response = await server.anthropic_async_client.beta.messages.batches.retrieve(batch_id_str)
         new_status = map_anthropic_batch_job_status_to_job_status(response.processing_status)
         logger.debug(f"[Poll BatchJob] Batch {batch_job.id}: provider={response.processing_status} → internal={new_status}")
-        return (batch_job.id, new_status, response)
+        return BatchPollingResult(batch_job.id, new_status, response)
     except Exception as e:
-        logger.warning(f"[Poll BatchJob] Batch {batch_job.id}: failed to retrieve {batch_id_str}: {e}")
+        logger.error(f"[Poll BatchJob] Batch {batch_job.id}: failed to retrieve {batch_id_str}: {e}")
         # We treat a retrieval error as still running to try again next cycle
-        return (batch_job.id, JobStatus.running, None)
+        return BatchPollingResult(batch_job.id, JobStatus.running, None)
 
 
-async def fetch_batch_items(server: SyncServer, batch_id: BatchId, batch_resp_id: str) -> List[ItemUpdateInfo]:
+async def fetch_batch_items(server: SyncServer, batch_id: str, batch_resp_id: str) -> List[ItemUpdateInfo]:
     """
     Fetch individual item results for a completed batch.
 
@@ -73,7 +76,7 @@ async def fetch_batch_items(server: SyncServer, batch_id: BatchId, batch_resp_id
         async for item_result in server.anthropic_async_client.beta.messages.batches.results(batch_resp_id):
             # Here, custom_id should be the agent_id
             item_status = map_anthropic_individual_batch_item_status_to_job_status(item_result)
-            updates.append((batch_id, item_result.custom_id, item_status, item_result))
+            updates.append(ItemUpdateInfo(batch_id, item_result.custom_id, item_status, item_result))
         logger.info(f"[Poll BatchJob] Fetched {len(updates)} item updates for batch {batch_id}.")
     except Exception as e:
         logger.error(f"[Poll BatchJob] Error fetching item updates for batch {batch_id}: {e}")
@@ -102,7 +105,7 @@ async def poll_batch_updates(server: SyncServer, batch_jobs: List[LLMBatchJob],
     results: List[BatchPollingResult] = await asyncio.gather(*coros)
 
     # Update the server with batch status changes
-    server.batch_manager.bulk_update_batch_statuses(updates=results)
+    server.batch_manager.bulk_update_llm_batch_statuses(updates=results)
     logger.info(f"[Poll BatchJob] Bulk-updated {len(results)} LLM batch(es) in the DB at job level.")
 
     return results
@@ -156,7 +159,7 @@ async def process_completed_batches(
     return item_updates
 
 
-async def poll_running_llm_batches(server: "SyncServer") -> None:
+async def poll_running_llm_batches(server: "SyncServer") -> List[LettaBatchResponse]:
     """
     Cron job to poll all running LLM batch jobs and update their polling responses in bulk.
 
@@ -176,7 +179,7 @@ async def poll_running_llm_batches(server: "SyncServer") -> None:
 
     try:
         # 1. Retrieve running batch jobs
-        batches = server.batch_manager.list_running_batches()
+        batches = server.batch_manager.list_running_llm_batches()
         metrics.total_batches = len(batches)
 
         # TODO: Expand to more providers
@@ -193,7 +196,33 @@ async def poll_running_llm_batches(server: "SyncServer") -> None:
         # 6. Bulk update all items for newly completed batch(es)
         if item_updates:
             metrics.updated_items_count = len(item_updates)
-            server.batch_manager.bulk_update_batch_items_by_agent(item_updates)
+            server.batch_manager.bulk_update_batch_llm_items_results_by_agent(item_updates)
+
+            # ─── Kick off post‑processing for each batch that just completed ───
+            completed = [r for r in batch_results if r.request_status == JobStatus.completed]
+
+            async def _resume(batch_row: LLMBatchJob) -> LettaBatchResponse:
+                actor: User = server.user_manager.get_user_by_id(batch_row.created_by_id)
+                runner = LettaAgentBatch(
+                    message_manager=server.message_manager,
+                    agent_manager=server.agent_manager,
+                    block_manager=server.block_manager,
+                    passage_manager=server.passage_manager,
+                    batch_manager=server.batch_manager,
+                    sandbox_config_manager=server.sandbox_config_manager,
+                    job_manager=server.job_manager,
+                    actor=actor,
+                )
+                return await runner.resume_step_after_request(
+                    letta_batch_id=batch_row.letta_batch_job_id,
+                    llm_batch_id=batch_row.id,
+                )
+
+            # launch them all at once
+            tasks = [_resume(server.batch_manager.get_llm_batch_job_by_id(bid)) for bid, *_ in completed]
+            new_batch_responses = await asyncio.gather(*tasks, return_exceptions=True)
+
+            return new_batch_responses
         else:
             logger.info("[Poll BatchJob] No item-level updates needed.")
 

letta/jobs/scheduler.py

@@ -4,27 +4,68 @@ from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from apscheduler.triggers.interval import IntervalTrigger
 
 from letta.jobs.llm_batch_job_polling import poll_running_llm_batches
+from letta.log import get_logger
+from letta.server.db import db_context
 from letta.server.server import SyncServer
 from letta.settings import settings
 
 scheduler = AsyncIOScheduler()
+logger = get_logger(__name__)
+STARTUP_LOCK_KEY = 0x12345678ABCDEF00
+
+_startup_lock_conn = None
+_startup_lock_cur = None
 
 
 def start_cron_jobs(server: SyncServer):
-    """Initialize cron jobs"""
-    if settings.enable_batch_job_polling:
-        scheduler.add_job(
-            poll_running_llm_batches,
-            args=[server],
-            trigger=IntervalTrigger(seconds=settings.poll_running_llm_batches_interval_seconds),
-            next_run_time=datetime.datetime.now(datetime.timezone.utc),
-            id="poll_llm_batches",
-            name="Poll LLM API batch jobs and update status",
-            replace_existing=True,
-        )
-        scheduler.start()
+    global _startup_lock_conn, _startup_lock_cur
+
+    if not settings.enable_batch_job_polling:
+        return
+
+    with db_context() as session:
+        engine = session.get_bind()
+
+    raw = engine.raw_connection()
+    cur = raw.cursor()
+    cur.execute("SELECT pg_try_advisory_lock(CAST(%s AS bigint))", (STARTUP_LOCK_KEY,))
+    got = cur.fetchone()[0]
+    if not got:
+        cur.close()
+        raw.close()
+        logger.info("Batch‐poller lock already held – not starting scheduler in this worker")
+        return
+
+    _startup_lock_conn, _startup_lock_cur = raw, cur
+    jitter_seconds = 10
+    trigger = IntervalTrigger(
+        seconds=settings.poll_running_llm_batches_interval_seconds,
+        jitter=jitter_seconds,
+    )
+
+    scheduler.add_job(
+        poll_running_llm_batches,
+        args=[server],
+        trigger=trigger,
+        next_run_time=datetime.datetime.now(datetime.timezone.utc),
+        id="poll_llm_batches",
+        name="Poll LLM API batch jobs",
+        replace_existing=True,
+    )
+    scheduler.start()
+    logger.info("Started batch‐polling scheduler in this worker")
 
 
 def shutdown_cron_scheduler():
-    if settings.enable_batch_job_polling:
+    global _startup_lock_conn, _startup_lock_cur
+
+    if settings.enable_batch_job_polling and scheduler.running:
         scheduler.shutdown()
+
+    if _startup_lock_cur is not None:
+        _startup_lock_cur.execute("SELECT pg_advisory_unlock(CAST(%s AS bigint))", (STARTUP_LOCK_KEY,))
+        _startup_lock_conn.commit()
+        _startup_lock_cur.close()
+        _startup_lock_conn.close()
+        _startup_lock_cur = None
+        _startup_lock_conn = None

letta/jobs/types.py

@@ -1,10 +1,30 @@
-from typing import Optional, Tuple
+from typing import NamedTuple, Optional
 
 from anthropic.types.beta.messages import BetaMessageBatch, BetaMessageBatchIndividualResponse
 
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import AgentStepStatus, JobStatus
 
-BatchId = str
-AgentId = str
-BatchPollingResult = Tuple[BatchId, JobStatus, Optional[BetaMessageBatch]]
-ItemUpdateInfo = Tuple[BatchId, AgentId, JobStatus, BetaMessageBatchIndividualResponse]
+
+class BatchPollingResult(NamedTuple):
+    llm_batch_id: str
+    request_status: JobStatus
+    batch_response: Optional[BetaMessageBatch]
+
+
+class ItemUpdateInfo(NamedTuple):
+    llm_batch_id: str
+    agent_id: str
+    request_status: JobStatus
+    batch_request_result: Optional[BetaMessageBatchIndividualResponse]
+
+
+class StepStatusUpdateInfo(NamedTuple):
+    llm_batch_id: str
+    agent_id: str
+    step_status: AgentStepStatus
+
+
+class RequestStatusUpdateInfo(NamedTuple):
+    llm_batch_id: str
+    agent_id: str
+    request_status: JobStatus

letta/llm_api/anthropic_client.py

@@ -4,7 +4,7 @@ from typing import Dict, List, Optional, Union
 
 import anthropic
 from anthropic import AsyncStream
-from anthropic.types import Message as AnthropicMessage
+from anthropic.types.beta import BetaMessage as AnthropicMessage
 from anthropic.types.beta import BetaRawMessageStreamEvent
 from anthropic.types.beta.message_create_params import MessageCreateParamsNonStreaming
 from anthropic.types.beta.messages import BetaMessageBatch
@@ -304,6 +304,8 @@ class AnthropicClient(LLMClientBase):
 
         return super().handle_llm_error(e)
 
+    # TODO: Input messages doesn't get used here
+    # TODO: Clean up this interface
     def convert_response_to_chat_completion(
         self,
         response_data: dict,

letta/llm_api/llm_api_tools.py

@@ -247,6 +247,13 @@ def create(
             use_structured_output=False,  # NOTE: not supported atm for xAI
         )
 
+        # Specific bug for the mini models (as of Apr 14, 2025)
+        # 400 - {'code': 'Client specified an invalid argument', 'error': 'Argument not supported on this model: presencePenalty'}
+        # 400 - {'code': 'Client specified an invalid argument', 'error': 'Argument not supported on this model: frequencyPenalty'}
+        if "grok-3-mini-" in llm_config.model:
+            data.presence_penalty = None
+            data.frequency_penalty = None
+
         if stream:  # Client requested token streaming
             data.stream = True
             assert isinstance(stream_interface, AgentChunkStreamingInterface) or isinstance(
@@ -322,7 +329,6 @@ def create(
 
         # Force tool calling
         tool_call = None
-        llm_config.put_inner_thoughts_in_kwargs = True
         if functions is None:
             # Special case for summarization path
             tools = None

letta/llm_api/openai.py

@@ -136,6 +136,7 @@ def build_openai_chat_completions_request(
             user=str(user_id),
             max_completion_tokens=llm_config.max_tokens,
             temperature=1.0 if llm_config.enable_reasoner else llm_config.temperature,
+            reasoning_effort=llm_config.reasoning_effort,
         )
     else:
         data = ChatCompletionRequest(
@@ -146,6 +147,7 @@ def build_openai_chat_completions_request(
             user=str(user_id),
             max_completion_tokens=llm_config.max_tokens,
             temperature=1.0 if llm_config.enable_reasoner else llm_config.temperature,
+            reasoning_effort=llm_config.reasoning_effort,
         )
         # https://platform.openai.com/docs/guides/text-generation/json-mode
         # only supported by gpt-4o, gpt-4-turbo, or gpt-3.5-turbo

letta/orm/agent.py

@@ -7,12 +7,11 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 from letta.orm.block import Block
 from letta.orm.custom_columns import EmbeddingConfigColumn, LLMConfigColumn, ToolRulesColumn
 from letta.orm.identity import Identity
-from letta.orm.message import Message
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.organization import Organization
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.agent import AgentState as PydanticAgentState
-from letta.schemas.agent import AgentType
+from letta.schemas.agent import AgentType, get_prompt_template_for_agent_type
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
@@ -91,13 +90,6 @@ class Agent(SqlalchemyBase, OrganizationMixin):
         back_populates="agents",
         doc="Blocks forming the core memory of the agent.",
     )
-    messages: Mapped[List["Message"]] = relationship(
-        "Message",
-        back_populates="agent",
-        lazy="selectin",
-        cascade="all, delete-orphan",  # Ensure messages are deleted when the agent is deleted
-        passive_deletes=True,
-    )
     tags: Mapped[List["AgentsTags"]] = relationship(
         "AgentsTags",
         back_populates="agent",
@@ -105,25 +97,6 @@ class Agent(SqlalchemyBase, OrganizationMixin):
         lazy="selectin",
         doc="Tags associated with the agent.",
     )
-    source_passages: Mapped[List["SourcePassage"]] = relationship(
-        "SourcePassage",
-        secondary="sources_agents",  # The join table for Agent -> Source
-        primaryjoin="Agent.id == sources_agents.c.agent_id",
-        secondaryjoin="and_(SourcePassage.source_id == sources_agents.c.source_id)",
-        lazy="selectin",
-        order_by="SourcePassage.created_at.desc()",
-        viewonly=True,  # Ensures SQLAlchemy doesn't attempt to manage this relationship
-        doc="All passages derived from sources associated with this agent.",
-    )
-    agent_passages: Mapped[List["AgentPassage"]] = relationship(
-        "AgentPassage",
-        back_populates="agent",
-        lazy="selectin",
-        order_by="AgentPassage.created_at.desc()",
-        cascade="all, delete-orphan",
-        viewonly=True,  # Ensures SQLAlchemy doesn't attempt to manage this relationship
-        doc="All passages derived created by this agent.",
-    )
     identities: Mapped[List["Identity"]] = relationship(
         "Identity",
         secondary="identities_agents",
@@ -202,7 +175,10 @@ class Agent(SqlalchemyBase, OrganizationMixin):
             "tags": lambda: [t.tag for t in self.tags],
             "tools": lambda: self.tools,
             "sources": lambda: [s.to_pydantic() for s in self.sources],
-            "memory": lambda: Memory(blocks=[b.to_pydantic() for b in self.core_memory]),
+            "memory": lambda: Memory(
+                blocks=[b.to_pydantic() for b in self.core_memory],
+                prompt_template=get_prompt_template_for_agent_type(self.agent_type),
+            ),
             "identity_ids": lambda: [i.id for i in self.identities],
             "multi_agent_group": lambda: self.multi_agent_group,
             "tool_exec_environment_variables": lambda: self.tool_exec_environment_variables,

letta/orm/base.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional
 
 from sqlalchemy import Boolean, DateTime, String, func, text
@@ -25,7 +25,7 @@ class CommonSqlalchemyMetaMixins(Base):
             timestamp (Optional[datetime]): The timestamp to set.
                                             If None, uses the current UTC time.
         """
-        self.updated_at = timestamp or datetime.utcnow()
+        self.updated_at = timestamp or datetime.now(timezone.utc)
 
     def _set_created_and_updated_by_fields(self, actor_id: str) -> None:
         """Populate created_by_id and last_updated_by_id based on actor."""

letta/orm/enums.py

@@ -16,6 +16,7 @@ class ToolType(str, Enum):
 class JobType(str, Enum):
     JOB = "job"
     RUN = "run"
+    BATCH = "batch"
 
 
 class ToolSourceType(str, Enum):

letta/orm/job.py

@@ -39,6 +39,11 @@ class Job(SqlalchemyBase, UserMixin):
         JSON, nullable=True, doc="The request configuration for the job, stored as JSON."
     )
 
+    # callback related columns
+    callback_url: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="When set, POST to this URL after job completion.")
+    callback_sent_at: Mapped[Optional[datetime]] = mapped_column(nullable=True, doc="Timestamp when the callback was last attempted.")
+    callback_status_code: Mapped[Optional[int]] = mapped_column(nullable=True, doc="HTTP status code returned by the callback endpoint.")
+
     # relationships
     user: Mapped["User"] = relationship("User", back_populates="jobs")
     job_messages: Mapped[List["JobMessage"]] = relationship("JobMessage", back_populates="job", cascade="all, delete-orphan")