letta-nightly 0.6.9.dev20250116104035__py3-none-any.whl → 0.6.9.dev20250117104025__py3-none-any.whl

letta/server/server.py

@@ -1,4 +1,5 @@
 # inspecting tools
+import asyncio
 import os
 import traceback
 import warnings
@@ -9,6 +10,7 @@ from typing import Callable, Dict, List, Optional, Tuple, Union
 from composio.client import Composio
 from composio.client.collections import ActionModel, AppModel
 from fastapi import HTTPException
+from fastapi.responses import StreamingResponse
 
 import letta.constants as constants
 import letta.server.utils as server_utils
@@ -30,10 +32,11 @@ from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import JobStatus, MessageStreamStatus
 from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate
 from letta.schemas.job import Job, JobUpdate
-from letta.schemas.letta_message import LettaMessage, ToolReturnMessage
+from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, ToolReturnMessage
+from letta.schemas.letta_response import LettaResponse
 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
@@ -57,6 +60,8 @@ from letta.schemas.source import Source
 from letta.schemas.tool import Tool
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
+from letta.server.rest_api.interface import StreamingServerInterface
+from letta.server.rest_api.utils import sse_async_generator
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
 from letta.services.job_manager import JobManager
@@ -425,12 +430,17 @@ class SyncServer(Server):
             token_streaming = letta_agent.interface.streaming_mode if hasattr(letta_agent.interface, "streaming_mode") else False
 
             logger.debug(f"Starting agent step")
+            if interface:
+                metadata = interface.metadata if hasattr(interface, "metadata") else None
+            else:
+                metadata = None
             usage_stats = letta_agent.step(
                 messages=input_messages,
                 chaining=self.chaining,
                 max_chaining_steps=self.max_chaining_steps,
                 stream=token_streaming,
                 skip_verify=True,
+                metadata=metadata,
             )
 
         except Exception as e:
@@ -687,6 +697,7 @@ class SyncServer(Server):
         wrap_user_message: bool = True,
         wrap_system_message: bool = True,
         interface: Union[AgentInterface, None] = None,  # needed to getting responses
+        metadata: Optional[dict] = None,  # Pass through metadata to interface
     ) -> LettaUsageStatistics:
         """Send a list of messages to the agent
 
@@ -732,6 +743,10 @@ class SyncServer(Server):
         else:
             raise ValueError(f"All messages must be of type Message or MessageCreate, got {[type(message) for message in messages]}")
 
+        # Store metadata in interface if provided
+        if metadata and hasattr(interface, "metadata"):
+            interface.metadata = metadata
+
         # Run the agent state forward
         return self._step(actor=actor, agent_id=agent_id, input_messages=message_objects, interface=interface)
 
@@ -1183,3 +1198,125 @@ class SyncServer(Server):
     def get_composio_actions_from_app_name(self, composio_app_name: str, api_key: Optional[str] = None) -> List["ActionModel"]:
         actions = self.get_composio_client(api_key=api_key).actions.get(apps=[composio_app_name])
         return actions
+
+    async def send_message_to_agent(
+        self,
+        agent_id: str,
+        actor: User,
+        # role: MessageRole,
+        messages: Union[List[Message], List[MessageCreate]],
+        stream_steps: bool,
+        stream_tokens: bool,
+        # related to whether or not we return `LettaMessage`s or `Message`s
+        chat_completion_mode: bool = False,
+        timestamp: Optional[datetime] = None,
+        # Support for AssistantMessage
+        use_assistant_message: bool = True,
+        assistant_message_tool_name: str = constants.DEFAULT_MESSAGE_TOOL,
+        assistant_message_tool_kwarg: str = constants.DEFAULT_MESSAGE_TOOL_KWARG,
+        metadata: Optional[dict] = None,
+    ) -> Union[StreamingResponse, LettaResponse]:
+        """Split off into a separate function so that it can be imported in the /chat/completion proxy."""
+
+        # TODO: @charles is this the correct way to handle?
+        include_final_message = True
+
+        if not stream_steps and stream_tokens:
+            raise HTTPException(status_code=400, detail="stream_steps must be 'true' if stream_tokens is 'true'")
+
+        # For streaming response
+        try:
+
+            # TODO: move this logic into server.py
+
+            # Get the generator object off of the agent's streaming interface
+            # This will be attached to the POST SSE request used under-the-hood
+            letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
+
+            # Disable token streaming if not OpenAI
+            # TODO: cleanup this logic
+            llm_config = letta_agent.agent_state.llm_config
+            if stream_tokens and (llm_config.model_endpoint_type != "openai" or "inference.memgpt.ai" in llm_config.model_endpoint):
+                warnings.warn(
+                    "Token streaming is only supported for models with type 'openai' or `inference.memgpt.ai` in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
+                )
+                stream_tokens = False
+
+            # Create a new interface per request
+            letta_agent.interface = StreamingServerInterface(use_assistant_message)
+            streaming_interface = letta_agent.interface
+            if not isinstance(streaming_interface, StreamingServerInterface):
+                raise ValueError(f"Agent has wrong type of interface: {type(streaming_interface)}")
+
+            # Enable token-streaming within the request if desired
+            streaming_interface.streaming_mode = stream_tokens
+            # "chatcompletion mode" does some remapping and ignores inner thoughts
+            streaming_interface.streaming_chat_completion_mode = chat_completion_mode
+
+            # streaming_interface.allow_assistant_message = stream
+            # streaming_interface.function_call_legacy_mode = stream
+
+            # Allow AssistantMessage is desired by client
+            streaming_interface.assistant_message_tool_name = assistant_message_tool_name
+            streaming_interface.assistant_message_tool_kwarg = assistant_message_tool_kwarg
+
+            # Related to JSON buffer reader
+            streaming_interface.inner_thoughts_in_kwargs = (
+                llm_config.put_inner_thoughts_in_kwargs if llm_config.put_inner_thoughts_in_kwargs is not None else False
+            )
+
+            # Offload the synchronous message_func to a separate thread
+            streaming_interface.stream_start()
+            task = asyncio.create_task(
+                asyncio.to_thread(
+                    self.send_messages,
+                    actor=actor,
+                    agent_id=agent_id,
+                    messages=messages,
+                    interface=streaming_interface,
+                    metadata=metadata,
+                )
+            )
+
+            if stream_steps:
+                # return a stream
+                return StreamingResponse(
+                    sse_async_generator(
+                        streaming_interface.get_generator(),
+                        usage_task=task,
+                        finish_message=include_final_message,
+                    ),
+                    media_type="text/event-stream",
+                )
+
+            else:
+                # buffer the stream, then return the list
+                generated_stream = []
+                async for message in streaming_interface.get_generator():
+                    assert (
+                        isinstance(message, LettaMessage)
+                        or isinstance(message, LegacyLettaMessage)
+                        or isinstance(message, MessageStreamStatus)
+                    ), type(message)
+                    generated_stream.append(message)
+                    if message == MessageStreamStatus.done:
+                        break
+
+                # Get rid of the stream status messages
+                filtered_stream = [d for d in generated_stream if not isinstance(d, MessageStreamStatus)]
+                usage = await task
+
+                # By default the stream will be messages of type LettaMessage or LettaLegacyMessage
+                # If we want to convert these to Message, we can use the attached IDs
+                # NOTE: we will need to de-duplicate the Messsage IDs though (since Assistant->Inner+Func_Call)
+                # TODO: eventually update the interface to use `Message` and `MessageChunk` (new) inside the deque instead
+                return LettaResponse(messages=filtered_stream, usage=usage)
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            print(e)
+            import traceback
+
+            traceback.print_exc()
+            raise HTTPException(status_code=500, detail=f"{e}")

letta/services/agent_manager.py

@@ -4,11 +4,11 @@ from typing import Dict, List, Optional
 import numpy as np
 from sqlalchemy import Select, func, literal, select, union_all
 
-from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS, MAX_EMBEDDING_DIM
+from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS, MAX_EMBEDDING_DIM, MULTI_AGENT_TOOLS
 from letta.embeddings import embedding_model
 from letta.log import get_logger
 from letta.orm import Agent as AgentModel
-from letta.orm import AgentPassage
+from letta.orm import AgentPassage, AgentsTags
 from letta.orm import Block as BlockModel
 from letta.orm import Source as SourceModel
 from letta.orm import SourcePassage, SourcesAgents
@@ -22,6 +22,7 @@ from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
+from letta.schemas.message import MessageCreate
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.tool_rule import ToolRule as PydanticToolRule
@@ -87,6 +88,8 @@ class AgentManager:
         tool_names = []
         if agent_create.include_base_tools:
             tool_names.extend(BASE_TOOLS + BASE_MEMORY_TOOLS)
+        if agent_create.include_multi_agent_tools:
+            tool_names.extend(MULTI_AGENT_TOOLS)
         if agent_create.tools:
             tool_names.extend(agent_create.tools)
         # Remove duplicates
@@ -125,13 +128,17 @@ class AgentManager:
                 actor=actor,
             )
 
-        # TODO: See if we can merge this into the above SQL create call for performance reasons
-        # Generate a sequence of initial messages to put in the buffer
+        return self.append_initial_message_sequence_to_in_context_messages(actor, agent_state, agent_create.initial_message_sequence)
+
+    @enforce_types
+    def append_initial_message_sequence_to_in_context_messages(
+        self, actor: PydanticUser, agent_state: PydanticAgentState, initial_message_sequence: Optional[List[MessageCreate]] = None
+    ) -> PydanticAgentState:
         init_messages = initialize_message_sequence(
             agent_state=agent_state, memory_edit_timestamp=get_utc_time(), include_initial_boot_message=True
         )
 
-        if agent_create.initial_message_sequence is not None:
+        if initial_message_sequence is not None:
             # We always need the system prompt up front
             system_message_obj = PydanticMessage.dict_to_message(
                 agent_id=agent_state.id,
@@ -142,7 +149,7 @@ class AgentManager:
             # Don't use anything else in the pregen sequence, instead use the provided sequence
             init_messages = [system_message_obj]
             init_messages.extend(
-                package_initial_message_sequence(agent_state.id, agent_create.initial_message_sequence, agent_state.llm_config.model, actor)
+                package_initial_message_sequence(agent_state.id, initial_message_sequence, agent_state.llm_config.model, actor)
             )
         else:
             init_messages = [
@@ -263,6 +270,7 @@ class AgentManager:
         match_all_tags: bool = False,
         cursor: Optional[str] = None,
         limit: Optional[int] = 50,
+        query_text: Optional[str] = None,
         **kwargs,
     ) -> List[PydanticAgentState]:
         """
@@ -276,6 +284,7 @@ class AgentManager:
                 cursor=cursor,
                 limit=limit,
                 organization_id=actor.organization_id if actor else None,
+                query_text=query_text,
                 **kwargs,
             )
 
@@ -468,6 +477,55 @@ class AgentManager:
         message_ids += [m.id for m in messages]
         return self.set_in_context_messages(agent_id=agent_id, message_ids=message_ids, actor=actor)
 
+    @enforce_types
+    def reset_messages(self, agent_id: str, actor: PydanticUser, add_default_initial_messages: bool = False) -> PydanticAgentState:
+        """
+        Removes all in-context messages for the specified agent by:
+          1) Clearing the agent.messages relationship (which cascades delete-orphans).
+          2) Resetting the message_ids list to empty.
+          3) Committing the transaction.
+
+        This action is destructive and cannot be undone once committed.
+
+        Args:
+            add_default_initial_messages: If true, adds the default initial messages after resetting.
+            agent_id (str): The ID of the agent whose messages will be reset.
+            actor (PydanticUser): The user performing this action.
+
+        Returns:
+            PydanticAgentState: The updated agent state with no linked messages.
+        """
+        with self.session_maker() as session:
+            # 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 = []
+
+            # Commit the update
+            agent.update(db_session=session, actor=actor)
+
+            agent_state = agent.to_pydantic()
+
+        if add_default_initial_messages:
+            return self.append_initial_message_sequence_to_in_context_messages(actor, agent_state)
+        else:
+            # We still want to always have a system message
+            init_messages = initialize_message_sequence(
+                agent_state=agent_state, memory_edit_timestamp=get_utc_time(), include_initial_boot_message=True
+            )
+            system_message = PydanticMessage.dict_to_message(
+                agent_id=agent_state.id,
+                user_id=agent_state.created_by_id,
+                model=agent_state.llm_config.model,
+                openai_message_dict=init_messages[0],
+            )
+            return self.append_to_in_context_messages([system_message], agent_id=agent_state.id, actor=actor)
+
     # ======================================================================================================================
     # Source Management
     # ======================================================================================================================
@@ -945,3 +1003,40 @@ class AgentManager:
             # Commit and refresh the agent
             agent.update(session, actor=actor)
             return agent.to_pydantic()
+
+    # ======================================================================================================================
+    # Tag Management
+    # ======================================================================================================================
+    @enforce_types
+    def list_tags(
+        self, actor: PydanticUser, cursor: Optional[str] = None, limit: Optional[int] = 50, query_text: Optional[str] = None
+    ) -> List[str]:
+        """
+        Get all tags a user has created, ordered alphabetically.
+
+        Args:
+            actor: User performing the action.
+            cursor: Cursor for pagination.
+            limit: Maximum number of tags to return.
+            query_text: Query text to filter tags by.
+
+        Returns:
+            List[str]: List of all tags.
+        """
+        with self.session_maker() as session:
+            query = (
+                session.query(AgentsTags.tag)
+                .join(AgentModel, AgentModel.id == AgentsTags.agent_id)
+                .filter(AgentModel.organization_id == actor.organization_id)
+                .distinct()
+            )
+
+            if query_text:
+                query = query.filter(AgentsTags.tag.ilike(f"%{query_text}%"))
+
+            if cursor:
+                query = query.filter(AgentsTags.tag > cursor)
+
+            query = query.order_by(AgentsTags.tag).limit(limit)
+            results = [tag[0] for tag in query.all()]
+            return results

letta/services/job_manager.py

@@ -1,9 +1,23 @@
-from typing import List, Optional
+from typing import List, Literal, Optional, Union
 
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from letta.orm.enums import JobType
+from letta.orm.errors import NoResultFound
 from letta.orm.job import Job as JobModel
-from letta.schemas.enums import JobStatus
+from letta.orm.job_messages import JobMessage
+from letta.orm.job_usage_statistics import JobUsageStatistics
+from letta.orm.message import Message as MessageModel
+from letta.orm.sqlalchemy_base import AccessType
+from letta.schemas.enums import JobStatus, MessageRole
 from letta.schemas.job import Job as PydanticJob
 from letta.schemas.job import JobUpdate
+from letta.schemas.letta_message import LettaMessage
+from letta.schemas.letta_request import LettaRequestConfig
+from letta.schemas.message import Message as PydanticMessage
+from letta.schemas.run import Run as PydanticRun
+from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types, get_utc_time
 
@@ -18,7 +32,7 @@ class JobManager:
         self.session_maker = db_context
 
     @enforce_types
-    def create_job(self, pydantic_job: PydanticJob, actor: PydanticUser) -> PydanticJob:
+    def create_job(self, pydantic_job: Union[PydanticJob, PydanticRun], actor: PydanticUser) -> Union[PydanticJob, PydanticRun]:
         """Create a new job based on the JobCreate schema."""
         with self.session_maker() as session:
             # Associate the job with the user
@@ -33,7 +47,7 @@ class JobManager:
         """Update a job by its ID with the given JobUpdate object."""
         with self.session_maker() as session:
             # Fetch the job by ID
-            job = JobModel.read(db_session=session, identifier=job_id)  # TODO: Add this later , actor=actor)
+            job = self._verify_job_access(session=session, job_id=job_id, actor=actor, access=["write"])
 
             # Update job attributes with only the fields that were explicitly set
             update_data = job_update.model_dump(exclude_unset=True, exclude_none=True)
@@ -53,16 +67,21 @@ class JobManager:
         """Fetch a job by its ID."""
         with self.session_maker() as session:
             # Retrieve job by ID using the Job model's read method
-            job = JobModel.read(db_session=session, identifier=job_id)  # TODO: Add this later , actor=actor)
+            job = JobModel.read(db_session=session, identifier=job_id, actor=actor, access_type=AccessType.USER)
             return job.to_pydantic()
 
     @enforce_types
     def list_jobs(
-        self, actor: PydanticUser, cursor: Optional[str] = None, limit: Optional[int] = 50, statuses: Optional[List[JobStatus]] = None
+        self,
+        actor: PydanticUser,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = 50,
+        statuses: Optional[List[JobStatus]] = None,
+        job_type: JobType = JobType.JOB,
     ) -> List[PydanticJob]:
         """List all jobs with optional pagination and status filter."""
         with self.session_maker() as session:
-            filter_kwargs = {"user_id": actor.id}
+            filter_kwargs = {"user_id": actor.id, "job_type": job_type}
 
             # Add status filter if provided
             if statuses:
@@ -80,6 +99,252 @@ class JobManager:
     def delete_job_by_id(self, job_id: str, actor: PydanticUser) -> PydanticJob:
         """Delete a job by its ID."""
         with self.session_maker() as session:
-            job = JobModel.read(db_session=session, identifier=job_id)  # TODO: Add this later , actor=actor)
-            job.hard_delete(db_session=session)  # TODO: Add this later , actor=actor)
+            job = self._verify_job_access(session=session, job_id=job_id, actor=actor)
+            job.hard_delete(db_session=session, actor=actor)
             return job.to_pydantic()
+
+    @enforce_types
+    def get_job_messages(
+        self,
+        job_id: str,
+        actor: PydanticUser,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = 100,
+        role: Optional[MessageRole] = None,
+        ascending: bool = True,
+    ) -> List[PydanticMessage]:
+        """
+        Get all messages associated with a job.
+
+        Args:
+            job_id: The ID of the job to get messages for
+            actor: The user making the request
+            cursor: Cursor for pagination
+            limit: Maximum number of messages to return
+            role: Optional filter for message role
+            ascending: Optional flag to sort in ascending order
+
+        Returns:
+            List of messages associated with the job
+
+        Raises:
+            NoResultFound: If the job does not exist or user does not have access
+        """
+        with self.session_maker() as session:
+            # Build filters
+            filters = {}
+            if role is not None:
+                filters["role"] = role
+
+            # Get messages
+            messages = MessageModel.list(
+                db_session=session,
+                cursor=cursor,
+                ascending=ascending,
+                limit=limit,
+                actor=actor,
+                join_model=JobMessage,
+                join_conditions=[MessageModel.id == JobMessage.message_id, JobMessage.job_id == job_id],
+                **filters,
+            )
+
+        return [message.to_pydantic() for message in messages]
+
+    @enforce_types
+    def add_message_to_job(self, job_id: str, message_id: str, actor: PydanticUser) -> None:
+        """
+        Associate a message with a job by creating a JobMessage record.
+        Each message can only be associated with one job.
+
+        Args:
+            job_id: The ID of the job
+            message_id: The ID of the message to associate
+            actor: The user making the request
+
+        Raises:
+            NoResultFound: If the job does not exist or user does not have access
+        """
+        with self.session_maker() as session:
+            # First verify job exists and user has access
+            self._verify_job_access(session, job_id, actor, access=["write"])
+
+            # Create new JobMessage association
+            job_message = JobMessage(job_id=job_id, message_id=message_id)
+            session.add(job_message)
+            session.commit()
+
+    @enforce_types
+    def get_job_usage(self, job_id: str, actor: PydanticUser) -> LettaUsageStatistics:
+        """
+        Get usage statistics for a job.
+
+        Args:
+            job_id: The ID of the job
+            actor: The user making the request
+
+        Returns:
+            Usage statistics for the job
+
+        Raises:
+            NoResultFound: If the job does not exist or user does not have access
+        """
+        with self.session_maker() as session:
+            # First verify job exists and user has access
+            self._verify_job_access(session, job_id, actor)
+
+            # Get the latest usage statistics for the job
+            latest_stats = (
+                session.query(JobUsageStatistics)
+                .filter(JobUsageStatistics.job_id == job_id)
+                .order_by(JobUsageStatistics.created_at.desc())
+                .first()
+            )
+
+            if not latest_stats:
+                return LettaUsageStatistics(
+                    completion_tokens=0,
+                    prompt_tokens=0,
+                    total_tokens=0,
+                    step_count=0,
+                )
+
+            return LettaUsageStatistics(
+                completion_tokens=latest_stats.completion_tokens,
+                prompt_tokens=latest_stats.prompt_tokens,
+                total_tokens=latest_stats.total_tokens,
+                step_count=latest_stats.step_count,
+            )
+
+    @enforce_types
+    def add_job_usage(
+        self,
+        job_id: str,
+        usage: LettaUsageStatistics,
+        step_id: Optional[str] = None,
+        actor: PydanticUser = None,
+    ) -> None:
+        """
+        Add usage statistics for a job.
+
+        Args:
+            job_id: The ID of the job
+            usage: Usage statistics for the job
+            step_id: Optional ID of the specific step within the job
+            actor: The user making the request
+
+        Raises:
+            NoResultFound: If the job does not exist or user does not have access
+        """
+        with self.session_maker() as session:
+            # First verify job exists and user has access
+            self._verify_job_access(session, job_id, actor, access=["write"])
+
+            # Create new usage statistics entry
+            usage_stats = JobUsageStatistics(
+                job_id=job_id,
+                completion_tokens=usage.completion_tokens,
+                prompt_tokens=usage.prompt_tokens,
+                total_tokens=usage.total_tokens,
+                step_count=usage.step_count,
+                step_id=step_id,
+            )
+            if actor:
+                usage_stats._set_created_and_updated_by_fields(actor.id)
+
+            session.add(usage_stats)
+            session.commit()
+
+    @enforce_types
+    def get_run_messages_cursor(
+        self,
+        run_id: str,
+        actor: PydanticUser,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = 100,
+        role: Optional[MessageRole] = None,
+        ascending: bool = True,
+    ) -> List[LettaMessage]:
+        """
+        Get messages associated with a job using cursor-based pagination.
+        This is a wrapper around get_job_messages that provides cursor-based pagination.
+
+        Args:
+            job_id: The ID of the job to get messages for
+            actor: The user making the request
+            cursor: Message ID to get messages after or before
+            limit: Maximum number of messages to return
+            ascending: Whether to return messages in ascending order
+            role: Optional role filter
+
+        Returns:
+            List of LettaMessages associated with the job
+
+        Raises:
+            NoResultFound: If the job does not exist or user does not have access
+        """
+        messages = self.get_job_messages(
+            job_id=run_id,
+            actor=actor,
+            cursor=cursor,
+            limit=limit,
+            role=role,
+            ascending=ascending,
+        )
+
+        request_config = self._get_run_request_config(run_id)
+
+        # Convert messages to LettaMessages
+        messages = [
+            msg
+            for m in messages
+            for msg in m.to_letta_message(
+                assistant_message=request_config["use_assistant_message"],
+                assistant_message_tool_name=request_config["assistant_message_tool_name"],
+                assistant_message_tool_kwarg=request_config["assistant_message_tool_kwarg"],
+            )
+        ]
+
+        return messages
+
+    def _verify_job_access(
+        self,
+        session: Session,
+        job_id: str,
+        actor: PydanticUser,
+        access: List[Literal["read", "write", "delete"]] = ["read"],
+    ) -> JobModel:
+        """
+        Verify that a job exists and the user has the required access.
+
+        Args:
+            session: The database session
+            job_id: The ID of the job to verify
+            actor: The user making the request
+
+        Returns:
+            The job if it exists and the user has access
+
+        Raises:
+            NoResultFound: If the job does not exist or user does not have access
+        """
+        job_query = select(JobModel).where(JobModel.id == job_id)
+        job_query = JobModel.apply_access_predicate(job_query, actor, access, AccessType.USER)
+        job = session.execute(job_query).scalar_one_or_none()
+        if not job:
+            raise NoResultFound(f"Job with id {job_id} does not exist or user does not have access")
+        return job
+
+    def _get_run_request_config(self, run_id: str) -> LettaRequestConfig:
+        """
+        Get the request config for a job.
+
+        Args:
+            job_id: The ID of the job to get messages for
+
+        Returns:
+            The request config for the job
+        """
+        with self.session_maker() as session:
+            job = session.query(JobModel).filter(JobModel.id == run_id).first()
+            request_config = job.request_config or LettaRequestConfig()
+        return request_config