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

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

@@ -121,7 +121,15 @@ def delete_source(
     Delete a data source.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-
+    source = server.source_manager.get_source_by_id(source_id=source_id)
+    agents = server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
+    for agent in agents:
+        if agent.enable_sleeptime:
+            try:
+                block = server.agent_manager.get_block_with_label(agent_id=agent.id, block_label=source.name, actor=actor)
+                server.block_manager.delete_block(block.id, actor)
+            except:
+                pass
     server.delete_source(source_id=source_id, actor=actor)
 
 
@@ -151,8 +159,9 @@ def upload_file_to_source(
     job_id = job.id
     server.job_manager.create_job(job, actor=actor)
 
-    # create background task
+    # create background tasks
     background_tasks.add_task(load_file_to_source_async, server, source_id=source.id, file=file, job_id=job.id, bytes=bytes, actor=actor)
+    background_tasks.add_task(sleeptime_document_ingest_async, server, source_id, actor)
 
     # return job information
     # Is this necessary? Can we just return the job from create_job?
@@ -196,6 +205,7 @@ def list_source_files(
 def delete_file_from_source(
     source_id: str,
     file_id: str,
+    background_tasks: BackgroundTasks,
     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
 ):
@@ -205,6 +215,7 @@ def delete_file_from_source(
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
     deleted_file = server.source_manager.delete_file(file_id=file_id, actor=actor)
+    background_tasks.add_task(sleeptime_document_ingest_async, server, source_id, actor, clear_history=True)
     if deleted_file is None:
         raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
 
@@ -222,3 +233,11 @@ def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, f
 
         # Pass the file to load_file_to_source
         server.load_file_to_source(source_id, file_path, job_id, actor)
+
+
+def sleeptime_document_ingest_async(server: SyncServer, source_id: str, actor: User, clear_history: bool = False):
+    source = server.source_manager.get_source_by_id(source_id=source_id)
+    agents = server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
+    for agent in agents:
+        if agent.enable_sleeptime:
+            server.sleeptime_document_ingest(agent, source, actor, clear_history)

letta/server/rest_api/utils.py

@@ -153,6 +153,7 @@ def create_input_messages(input_messages: List[MessageCreate], agent_id: str, ac
             content=input_message.content,
             name=input_message.name,
             otid=input_message.otid,
+            sender_id=input_message.sender_id,
             organization_id=actor.organization_id,
             agent_id=agent_id,
             model=None,
@@ -224,22 +225,34 @@ def create_letta_messages_from_llm_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(text_content))],
-            organization_id=actor.organization_id,
-            agent_id=agent_id,
-            model=model,
-            tool_calls=[],
-            tool_call_id=None,
-            created_at=get_utc_time(),
+        heartbeat_system_message = create_heartbeat_system_message(
+            agent_id=agent_id, model=model, function_call_success=function_call_success, actor=actor
         )
         messages.append(heartbeat_system_message)
 
     return messages
 
 
+def create_heartbeat_system_message(
+    agent_id: str,
+    model: str,
+    function_call_success: bool,
+    actor: User,
+) -> 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(text_content))],
+        organization_id=actor.organization_id,
+        agent_id=agent_id,
+        model=model,
+        tool_calls=[],
+        tool_call_id=None,
+        created_at=get_utc_time(),
+    )
+    return heartbeat_system_message
+
+
 def create_assistant_messages_from_openai_response(
     response_text: str,
     agent_id: str,

letta/server/server.py

@@ -34,8 +34,9 @@ from letta.interface import AgentInterface  # abstract
 from letta.interface import CLIInterface  # for printing to terminal
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
+from letta.prompts.gpt_system import get_system_text
 from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgent
-from letta.schemas.block import BlockUpdate, CreateBlock
+from letta.schemas.block import Block, BlockUpdate, CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
@@ -67,7 +68,7 @@ from letta.schemas.providers import (
     TogetherProvider,
     VLLMChatCompletionsProvider,
     VLLMCompletionsProvider,
-    xAIProvider,
+    XAIProvider,
 )
 from letta.schemas.sandbox_config import SandboxType
 from letta.schemas.source import Source
@@ -94,9 +95,8 @@ from letta.services.tool_executor.tool_execution_sandbox import ToolExecutionSan
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
 from letta.settings import model_settings, settings, tool_settings
-from letta.sleeptime_agent import SleeptimeAgent
 from letta.tracing import log_event, trace_method
-from letta.utils import get_friendly_error_msg, make_key
+from letta.utils import get_friendly_error_msg, get_persona_text, make_key
 
 config = LettaConfig.load()
 logger = get_logger(__name__)
@@ -321,7 +321,7 @@ class SyncServer(Server):
         if model_settings.deepseek_api_key:
             self._enabled_providers.append(DeepSeekProvider(api_key=model_settings.deepseek_api_key))
         if model_settings.xai_api_key:
-            self._enabled_providers.append(xAIProvider(api_key=model_settings.xai_api_key))
+            self._enabled_providers.append(XAIProvider(api_key=model_settings.xai_api_key))
 
         # For MCP
         """Initialize the MCP clients (there may be multiple)"""
@@ -365,14 +365,7 @@ class SyncServer(Server):
             )
 
         interface = interface or self.default_interface_factory()
-        if agent_state.agent_type == AgentType.memgpt_agent:
-            agent = Agent(agent_state=agent_state, interface=interface, user=actor, mcp_clients=self.mcp_clients)
-        elif agent_state.agent_type == AgentType.sleeptime_agent:
-            agent = SleeptimeAgent(agent_state=agent_state, interface=interface, user=actor)
-        else:
-            raise ValueError(f"Invalid agent type {agent_state.agent_type}")
-
-        return agent
+        return Agent(agent_state=agent_state, interface=interface, user=actor, mcp_clients=self.mcp_clients)
 
     def _step(
         self,
@@ -996,12 +989,6 @@ class SyncServer(Server):
         connector = DirectoryConnector(input_files=[file_path])
         num_passages, num_documents = self.load_data(user_id=source.created_by_id, source_name=source.name, connector=connector)
 
-        # update job status
-        job.status = JobStatus.completed
-        job.metadata["num_passages"] = num_passages
-        job.metadata["num_documents"] = num_documents
-        self.job_manager.update_job_by_id(job_id=job_id, job_update=JobUpdate(**job.model_dump()), actor=actor)
-
         # update all agents who have this source attached
         agent_states = self.source_manager.list_attached_agents(source_id=source_id, actor=actor)
         for agent_state in agent_states:
@@ -1009,15 +996,74 @@ class SyncServer(Server):
 
             # Attach source to agent
             curr_passage_size = self.agent_manager.passage_size(actor=actor, agent_id=agent_id)
-            self.agent_manager.attach_source(agent_id=agent_state.id, source_id=source_id, actor=actor)
+            agent_state = self.agent_manager.attach_source(agent_id=agent_state.id, source_id=source_id, actor=actor)
             new_passage_size = self.agent_manager.passage_size(actor=actor, agent_id=agent_id)
             assert new_passage_size >= curr_passage_size  # in case empty files are added
 
             # rebuild system prompt and force
-            self.agent_manager.rebuild_system_prompt(agent_id=agent_id, actor=actor, force=True)
+            agent_state = self.agent_manager.rebuild_system_prompt(agent_id=agent_id, actor=actor, force=True)
+
+        # update job status
+        job.status = JobStatus.completed
+        job.metadata["num_passages"] = num_passages
+        job.metadata["num_documents"] = num_documents
+        self.job_manager.update_job_by_id(job_id=job_id, job_update=JobUpdate(**job.model_dump()), actor=actor)
 
         return job
 
+    def sleeptime_document_ingest(self, main_agent: AgentState, source: Source, actor: User, clear_history: bool = False) -> None:
+        sleeptime_agent = self.create_document_sleeptime_agent(main_agent, source, actor, clear_history)
+        agent = self.load_agent(agent_id=sleeptime_agent.id, actor=actor)
+        for passage in self.list_data_source_passages(source_id=source.id, user_id=actor.id):
+            agent.step(
+                messages=[
+                    Message(
+                        role="user",
+                        content=[TextContent(text=passage.text)],
+                        agent_id=sleeptime_agent.id,
+                    ),
+                ]
+            )
+        self.agent_manager.delete_agent(agent_id=sleeptime_agent.id, actor=actor)
+
+    def create_document_sleeptime_agent(
+        self, main_agent: AgentState, source: Source, actor: User, clear_history: bool = False
+    ) -> AgentState:
+        try:
+            block = self.agent_manager.get_block_with_label(agent_id=main_agent.id, block_label=source.name, actor=actor)
+        except:
+            block = self.block_manager.create_or_update_block(Block(label=source.name, value=""), actor=actor)
+            self.agent_manager.attach_block(agent_id=main_agent.id, block_id=block.id, actor=actor)
+
+        if clear_history and block.value != "":
+            block = self.block_manager.update_block(block_id=block.id, block=BlockUpdate(value=""))
+
+        request = CreateAgent(
+            name=main_agent.name + "-doc-sleeptime",
+            system=get_system_text("sleeptime_doc_ingest"),
+            agent_type=AgentType.sleeptime_agent,
+            block_ids=[block.id],
+            memory_blocks=[
+                CreateBlock(
+                    label="persona",
+                    value=get_persona_text("sleeptime_doc_persona"),
+                ),
+                CreateBlock(
+                    label="instructions",
+                    value=source.description,
+                ),
+            ],
+            llm_config=main_agent.llm_config,
+            embedding_config=main_agent.embedding_config,
+            project_id=main_agent.project_id,
+            include_base_tools=False,
+            tools=constants.BASE_SLEEPTIME_TOOLS,
+        )
+        return self.agent_manager.create_agent(
+            agent_create=request,
+            actor=actor,
+        )
+
     def load_data(
         self,
         user_id: str,

letta/services/agent_manager.py

@@ -30,10 +30,11 @@ from letta.orm.sandbox_config import AgentEnvironmentVariable as AgentEnvironmen
 from letta.orm.sqlalchemy_base import AccessType
 from letta.orm.sqlite_functions import adapt_array
 from letta.schemas.agent import AgentState as PydanticAgentState
-from letta.schemas.agent import AgentType, CreateAgent, UpdateAgent
+from letta.schemas.agent import AgentType, CreateAgent, UpdateAgent, get_prompt_template_for_agent_type
 from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.group import Group as PydanticGroup
 from letta.schemas.group import ManagerType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
@@ -43,11 +44,11 @@ from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool_rule import ContinueToolRule as PydanticContinueToolRule
-from letta.schemas.tool_rule import ParentToolRule as PydanticParentToolRule
 from letta.schemas.tool_rule import TerminalToolRule as PydanticTerminalToolRule
 from letta.schemas.tool_rule import ToolRule as PydanticToolRule
 from letta.schemas.user import User as PydanticUser
 from letta.serialize_schemas import MarshmallowAgentSchema
+from letta.serialize_schemas.marshmallow_message import SerializedMessageSchema
 from letta.serialize_schemas.marshmallow_tool import SerializedToolSchema
 from letta.serialize_schemas.pydantic_agent_schema import AgentSchema
 from letta.services.block_manager import BlockManager
@@ -158,14 +159,11 @@ class AgentManager:
         if agent_create.include_base_tool_rules:
             # apply default tool rules
             for tool_name in tool_names:
-                if tool_name == "send_message" or tool_name == "send_message_to_agent_async" or tool_name == "finish_rethinking_memory":
+                if tool_name == "send_message" or tool_name == "send_message_to_agent_async" or tool_name == "memory_finish_edits":
                     tool_rules.append(PydanticTerminalToolRule(tool_name=tool_name))
                 elif tool_name in BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_SLEEPTIME_TOOLS:
                     tool_rules.append(PydanticContinueToolRule(tool_name=tool_name))
 
-            if agent_create.agent_type == AgentType.sleeptime_agent:
-                tool_rules.append(PydanticParentToolRule(tool_name="view_core_memory_with_line_numbers", children=["core_memory_insert"]))
-
         # if custom rules, check tool rules are valid
         if agent_create.tool_rules:
             check_supports_structured_output(model=agent_create.llm_config.model, tool_rules=agent_create.tool_rules)
@@ -304,7 +302,7 @@ class AgentManager:
             agent_update.system = derive_system_message(
                 agent_type=agent_state.agent_type,
                 enable_sleeptime=agent_update.enable_sleeptime,
-                system=agent_update.system,
+                system=agent_update.system or agent_state.system,
             )
         if agent_update.system and agent_update.system != agent_state.system:
             agent_state = self.rebuild_system_prompt(agent_id=agent_state.id, actor=actor, force=True, update_timestamp=False)
@@ -422,7 +420,8 @@ class AgentManager:
             query = _apply_tag_filter(query, tags, match_all_tags)
             query = _apply_pagination(query, before, after, session, ascending=ascending)
 
-            query = query.limit(limit)
+            if limit:
+                query = query.limit(limit)
 
             agents = session.execute(query).scalars().all()
             return [agent.to_pydantic(include_relationships=include_relationships) for agent in agents]
@@ -530,7 +529,6 @@ class AgentManager:
     @enforce_types
     def serialize(self, agent_id: str, actor: PydanticUser) -> AgentSchema:
         with self.session_maker() as session:
-            # Retrieve the agent
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             schema = MarshmallowAgentSchema(session=session, actor=actor)
             data = schema.dump(agent)
@@ -546,12 +544,24 @@ class AgentManager:
         project_id: Optional[str] = None,
         strip_messages: Optional[bool] = False,
     ) -> PydanticAgentState:
-        serialized_agent = serialized_agent.model_dump()
-        tool_data_list = serialized_agent.pop("tools", [])
+        serialized_agent_dict = serialized_agent.model_dump()
+        tool_data_list = serialized_agent_dict.pop("tools", [])
+        messages = serialized_agent_dict.pop(MarshmallowAgentSchema.FIELD_MESSAGES, [])
+
+        for msg in messages:
+            msg[MarshmallowAgentSchema.FIELD_ID] = SerializedMessageSchema.generate_id()  # Generate new ID
+
+        message_ids = []
+        in_context_message_indices = serialized_agent_dict.pop(MarshmallowAgentSchema.FIELD_IN_CONTEXT_INDICES)
+        for idx in in_context_message_indices:
+            message_ids.append(messages[idx][MarshmallowAgentSchema.FIELD_ID])
+
+        serialized_agent_dict[MarshmallowAgentSchema.FIELD_MESSAGE_IDS] = message_ids
 
         with self.session_maker() as session:
             schema = MarshmallowAgentSchema(session=session, actor=actor)
-            agent = schema.load(serialized_agent, session=session)
+            agent = schema.load(serialized_agent_dict, session=session)
+
             if append_copy_suffix:
                 agent.name += "_copy"
             if project_id:
@@ -561,17 +571,23 @@ class AgentManager:
                 # we want to strip all but the first (system) message
                 agent.message_ids = [agent.message_ids[0]]
             agent = agent.create(session, actor=actor)
+
             pydantic_agent = agent.to_pydantic()
 
+        pyd_msgs = []
+        message_schema = SerializedMessageSchema(session=session, actor=actor)
+
+        for serialized_message in messages:
+            pydantic_message = message_schema.load(serialized_message, session=session).to_pydantic()
+            pydantic_message.agent_id = agent.id
+            pyd_msgs.append(pydantic_message)
+        self.message_manager.create_many_messages(pyd_msgs, actor=actor)
+
         # Need to do this separately as there's some fancy upsert logic that SqlAlchemy cannot handle
         for tool_data in tool_data_list:
             pydantic_tool = SerializedToolSchema(actor=actor).load(tool_data, transient=True).to_pydantic()
 
             existing_pydantic_tool = self.tool_manager.get_tool_by_name(pydantic_tool.name, actor=actor)
-            # If the tool exists
-            # AND EITHER:
-            # 1) override_existing_tools is set to False
-            # 2) existing_pydantic_tool is NOT any type of Letta core tool
             if existing_pydantic_tool and (
                 existing_pydantic_tool.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MULTI_AGENT_CORE, ToolType.LETTA_MEMORY_CORE}
                 or not override_existing_tools
@@ -642,6 +658,14 @@ class AgentManager:
             # Return the updated agent state
             return agent.to_pydantic()
 
+    @enforce_types
+    def list_groups(self, agent_id: str, actor: PydanticUser, manager_type: Optional[str] = None) -> List[PydanticGroup]:
+        with self.session_maker() as session:
+            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+            if manager_type:
+                return [group.to_pydantic() for group in agent.groups if group.manager_type == manager_type]
+            return [group.to_pydantic() for group in agent.groups]
+
     # ======================================================================================================================
     # In Context Messages Management
     # ======================================================================================================================
@@ -781,10 +805,6 @@ class AgentManager:
             # Retrieve the existing agent (will raise NoResultFound if invalid)
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
-            # Because of cascade="all, delete-orphan" on agent.messages, setting
-            # this relationship to an empty list will physically remove them from the DB.
-            agent.messages = []
-
             # Also clear out the message_ids field to keep in-context memory consistent
             agent.message_ids = []
 
@@ -793,6 +813,8 @@ class AgentManager:
 
             agent_state = agent.to_pydantic()
 
+        self.message_manager.delete_all_messages_for_agent(agent_id=agent_id, actor=actor)
+
         if add_default_initial_messages:
             return self.append_initial_message_sequence_to_in_context_messages(actor, agent_state)
         else:
@@ -833,7 +855,8 @@ class AgentManager:
 
             # refresh memory from DB (using block ids)
             agent_state.memory = Memory(
-                blocks=[self.block_manager.get_block_by_id(block.id, actor=actor) for block in agent_state.memory.get_blocks()]
+                blocks=[self.block_manager.get_block_by_id(block.id, actor=actor) for block in agent_state.memory.get_blocks()],
+                prompt_template=get_prompt_template_for_agent_type(agent_state.agent_type),
             )
 
             # NOTE: don't do this since re-buildin the memory is handled at the start of the step

letta/services/group_manager.py

@@ -76,7 +76,7 @@ class GroupManager:
                     new_group.manager_agent_id = group.manager_config.manager_agent_id
                     new_group.sleeptime_agent_frequency = group.manager_config.sleeptime_agent_frequency
                     if new_group.sleeptime_agent_frequency:
-                        new_group.turns_counter = 0
+                        new_group.turns_counter = -1
                 case _:
                     raise ValueError(f"Unsupported manager type: {group.manager_config.manager_type}")
 
@@ -113,7 +113,7 @@ class GroupManager:
                         manager_agent_id = group_update.manager_config.manager_agent_id
                         sleeptime_agent_frequency = group_update.manager_config.sleeptime_agent_frequency
                         if sleeptime_agent_frequency and group.turns_counter is None:
-                            group.turns_counter = 0
+                            group.turns_counter = -1
                     case _:
                         raise ValueError(f"Unsupported manager type: {group_update.manager_config.manager_type}")
 

letta/services/helpers/agent_manager_helper.py

@@ -194,10 +194,9 @@ def compile_system_message(
         variables[IN_CONTEXT_MEMORY_KEYWORD] = full_memory_string
 
     if template_format == "f-string":
-
+        memory_variable_string = "{" + IN_CONTEXT_MEMORY_KEYWORD + "}"
         # Catch the special case where the system prompt is unformatted
         if append_icm_if_missing:
-            memory_variable_string = "{" + IN_CONTEXT_MEMORY_KEYWORD + "}"
             if memory_variable_string not in system_prompt:
                 # In this case, append it to the end to make sure memory is still injected
                 # warnings.warn(f"{IN_CONTEXT_MEMORY_KEYWORD} variable was missing from system prompt, appending instead")
@@ -205,7 +204,10 @@ def compile_system_message(
 
         # render the variables using the built-in templater
         try:
-            formatted_prompt = safe_format(system_prompt, variables)
+            if user_defined_variables:
+                formatted_prompt = safe_format(system_prompt, variables)
+            else:
+                formatted_prompt = system_prompt.replace(memory_variable_string, full_memory_string)
         except Exception as e:
             raise ValueError(f"Failed to format system prompt - {str(e)}. System prompt value:\n{system_prompt}")
 

letta/services/job_manager.py

@@ -15,6 +15,7 @@ from letta.orm.sqlalchemy_base import AccessType
 from letta.orm.step import Step
 from letta.orm.step import Step as StepModel
 from letta.schemas.enums import JobStatus, MessageRole
+from letta.schemas.job import BatchJob as PydanticBatchJob
 from letta.schemas.job import Job as PydanticJob
 from letta.schemas.job import JobUpdate, LettaRequestConfig
 from letta.schemas.letta_message import LettaMessage
@@ -36,7 +37,9 @@ class JobManager:
         self.session_maker = db_context
 
     @enforce_types
-    def create_job(self, pydantic_job: Union[PydanticJob, PydanticRun], actor: PydanticUser) -> Union[PydanticJob, PydanticRun]:
+    def create_job(
+        self, pydantic_job: Union[PydanticJob, PydanticRun, PydanticBatchJob], actor: PydanticUser
+    ) -> Union[PydanticJob, PydanticRun, PydanticBatchJob]:
         """Create a new job based on the JobCreate schema."""
         with self.session_maker() as session:
             # Associate the job with the user
@@ -57,14 +60,16 @@ class JobManager:
             update_data = job_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
 
             # Automatically update the completion timestamp if status is set to 'completed'
-            if update_data.get("status") == JobStatus.completed and not job.completed_at:
-                job.completed_at = get_utc_time()
-
             for key, value in update_data.items():
                 setattr(job, key, value)
 
+            if update_data.get("status") == JobStatus.completed and not job.completed_at:
+                job.completed_at = get_utc_time()
+                if job.callback_url:
+                    self._dispatch_callback(session, job)
+
             # Save the updated job to the database
-            job.update(db_session=session)  # TODO: Add this later , actor=actor)
+            job.update(db_session=session, actor=actor)
 
             return job.to_pydantic()
 
@@ -452,3 +457,27 @@ class JobManager:
             job = session.query(JobModel).filter(JobModel.id == run_id).first()
             request_config = job.request_config or LettaRequestConfig()
         return request_config
+
+    def _dispatch_callback(self, session: Session, job: JobModel) -> None:
+        """
+        POST a standard JSON payload to job.callback_url
+        and record timestamp + HTTP status.
+        """
+
+        payload = {
+            "job_id": job.id,
+            "status": job.status,
+            "completed_at": job.completed_at.isoformat(),
+        }
+        try:
+            import httpx
+
+            resp = httpx.post(job.callback_url, json=payload, timeout=5.0)
+            job.callback_sent_at = get_utc_time()
+            job.callback_status_code = resp.status_code
+
+        except Exception:
+            return
+
+        session.add(job)
+        session.commit()