letta-nightly 0.6.3.dev20241213104231__py3-none-any.whl → 0.6.4.dev20241214104034__py3-none-any.whl

letta/server/rest_api/routers/openai/assistants/threads.py

@@ -1,338 +0,0 @@
-import uuid
-from typing import TYPE_CHECKING, List, Optional
-
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Path, Query
-
-from letta.constants import DEFAULT_PRESET
-from letta.schemas.agent import CreateAgent
-from letta.schemas.enums import MessageRole
-from letta.schemas.message import Message
-from letta.schemas.openai.openai import (
-    MessageFile,
-    OpenAIMessage,
-    OpenAIRun,
-    OpenAIRunStep,
-    OpenAIThread,
-    Text,
-)
-from letta.server.rest_api.routers.openai.assistants.schemas import (
-    CreateMessageRequest,
-    CreateRunRequest,
-    CreateThreadRequest,
-    CreateThreadRunRequest,
-    DeleteThreadResponse,
-    ListMessagesResponse,
-    ModifyMessageRequest,
-    ModifyRunRequest,
-    ModifyThreadRequest,
-    OpenAIThread,
-    SubmitToolOutputsToRunRequest,
-)
-from letta.server.rest_api.utils import get_letta_server
-from letta.server.server import SyncServer
-
-if TYPE_CHECKING:
-    from letta.utils import get_utc_time
-
-
-# TODO: implement mechanism for creating/authenticating users associated with a bearer token
-router = APIRouter(prefix="/v1/threads", tags=["threads"])
-
-
-@router.post("/", response_model=OpenAIThread)
-def create_thread(
-    request: CreateThreadRequest = Body(...),
-    server: SyncServer = Depends(get_letta_server),
-    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-):
-    # TODO: use requests.description and requests.metadata fields
-    # TODO: handle requests.file_ids and requests.tools
-    # TODO: eventually allow request to override embedding/llm model
-    actor = server.get_user_or_default(user_id=user_id)
-
-    print("Create thread/agent", request)
-    # create a letta agent
-    agent_state = server.create_agent(
-        request=CreateAgent(),
-        user_id=actor.id,
-    )
-    # TODO: insert messages into recall memory
-    return OpenAIThread(
-        id=str(agent_state.id),
-        created_at=int(agent_state.created_at.timestamp()),
-        metadata={},  # TODO add metadata?
-    )
-
-
-@router.get("/{thread_id}", response_model=OpenAIThread)
-def retrieve_thread(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    server: SyncServer = Depends(get_letta_server),
-    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-):
-    actor = server.get_user_or_default(user_id=user_id)
-    agent = server.get_agent(user_id=actor.id, agent_id=thread_id)
-    assert agent is not None
-    return OpenAIThread(
-        id=str(agent.id),
-        created_at=int(agent.created_at.timestamp()),
-        metadata={},  # TODO add metadata?
-    )
-
-
-@router.get("/{thread_id}", response_model=OpenAIThread)
-def modify_thread(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    request: ModifyThreadRequest = Body(...),
-):
-    # TODO: add agent metadata so this can be modified
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.delete("/{thread_id}", response_model=DeleteThreadResponse)
-def delete_thread(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-):
-    # TODO: delete agent
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.post("/{thread_id}/messages", tags=["messages"], response_model=OpenAIMessage)
-def create_message(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    request: CreateMessageRequest = Body(...),
-    server: SyncServer = Depends(get_letta_server),
-    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-):
-    actor = server.get_user_or_default(user_id=user_id)
-    agent_id = thread_id
-    # create message object
-    message = Message(
-        user_id=actor.id,
-        agent_id=agent_id,
-        role=MessageRole(request.role),
-        text=request.content,
-        model=None,
-        tool_calls=None,
-        tool_call_id=None,
-        name=None,
-    )
-    agent = server.load_agent(agent_id=agent_id)
-    # add message to agent
-    agent._append_to_messages([message])
-
-    openai_message = OpenAIMessage(
-        id=str(message.id),
-        created_at=int(message.created_at.timestamp()),
-        content=[Text(text=(message.text if message.text else ""))],
-        role=message.role,
-        thread_id=str(message.agent_id),
-        assistant_id=DEFAULT_PRESET,  # TODO: update this
-        # TODO(sarah) fill in?
-        run_id=None,
-        file_ids=None,
-        metadata=None,
-        # file_ids=message.file_ids,
-        # metadata=message.metadata,
-    )
-    return openai_message
-
-
-@router.get("/{thread_id}/messages", tags=["messages"], response_model=ListMessagesResponse)
-def list_messages(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    limit: int = Query(1000, description="How many messages to retrieve."),
-    order: str = Query("asc", description="Order of messages to retrieve (either 'asc' or 'desc')."),
-    after: str = Query(None, description="A cursor for use in pagination. `after` is an object ID that defines your place in the list."),
-    before: str = Query(None, description="A cursor for use in pagination. `after` is an object ID that defines your place in the list."),
-    server: SyncServer = Depends(get_letta_server),
-    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-):
-    actor = server.get_user_or_default(user_id)
-    after_uuid = after if before else None
-    before_uuid = before if before else None
-    agent_id = thread_id
-    reverse = True if (order == "desc") else False
-    json_messages = server.get_agent_recall_cursor(
-        user_id=actor.id,
-        agent_id=agent_id,
-        limit=limit,
-        after=after_uuid,
-        before=before_uuid,
-        order_by="created_at",
-        reverse=reverse,
-    )
-    assert isinstance(json_messages, List)
-    assert all([isinstance(message, Message) for message in json_messages])
-    assert isinstance(json_messages[0], Message)
-    print(json_messages[0].text)
-    # convert to openai style messages
-    openai_messages = []
-    for message in json_messages:
-        assert isinstance(message, Message)
-        openai_messages.append(
-            OpenAIMessage(
-                id=str(message.id),
-                created_at=int(message.created_at.timestamp()),
-                content=[Text(text=(message.text if message.text else ""))],
-                role=str(message.role),
-                thread_id=str(message.agent_id),
-                assistant_id=DEFAULT_PRESET,  # TODO: update this
-                # TODO(sarah) fill in?
-                run_id=None,
-                file_ids=None,
-                metadata=None,
-                # file_ids=message.file_ids,
-                # metadata=message.metadata,
-            )
-        )
-    print("MESSAGES", openai_messages)
-    # TODO: cast back to message objects
-    return ListMessagesResponse(messages=openai_messages)
-
-
-@router.get("/{thread_id}/messages/{message_id}", tags=["messages"], response_model=OpenAIMessage)
-def retrieve_message(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    message_id: str = Path(..., description="The unique identifier of the message."),
-    server: SyncServer = Depends(get_letta_server),
-):
-    agent_id = thread_id
-    message = server.get_agent_message(agent_id=agent_id, message_id=message_id)
-    assert message is not None
-    return OpenAIMessage(
-        id=message_id,
-        created_at=int(message.created_at.timestamp()),
-        content=[Text(text=(message.text if message.text else ""))],
-        role=message.role,
-        thread_id=str(message.agent_id),
-        assistant_id=DEFAULT_PRESET,  # TODO: update this
-        # TODO(sarah) fill in?
-        run_id=None,
-        file_ids=None,
-        metadata=None,
-        # file_ids=message.file_ids,
-        # metadata=message.metadata,
-    )
-
-
-@router.get("/{thread_id}/messages/{message_id}/files/{file_id}", tags=["messages"], response_model=MessageFile)
-def retrieve_message_file(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    message_id: str = Path(..., description="The unique identifier of the message."),
-    file_id: str = Path(..., description="The unique identifier of the file."),
-):
-    # TODO: implement?
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.post("/{thread_id}/messages/{message_id}", tags=["messages"], response_model=OpenAIMessage)
-def modify_message(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    message_id: str = Path(..., description="The unique identifier of the message."),
-    request: ModifyMessageRequest = Body(...),
-):
-    # TODO: add metada field to message so this can be modified
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.post("/{thread_id}/runs", tags=["runs"], response_model=OpenAIRun)
-def create_run(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    request: CreateRunRequest = Body(...),
-    server: SyncServer = Depends(get_letta_server),
-):
-
-    # TODO: add request.instructions as a message?
-    agent_id = thread_id
-    # TODO: override preset of agent with request.assistant_id
-    agent = server.load_agent(agent_id=agent_id)
-    agent.inner_step(messages=[])  # already has messages added
-    run_id = str(uuid.uuid4())
-    create_time = int(get_utc_time().timestamp())
-    return OpenAIRun(
-        id=run_id,
-        created_at=create_time,
-        thread_id=str(agent_id),
-        assistant_id=DEFAULT_PRESET,  # TODO: update this
-        status="completed",  # TODO: eventaully allow offline execution
-        expires_at=create_time,
-        model=agent.agent_state.llm_config.model,
-        instructions=request.instructions,
-    )
-
-
-@router.post("/runs", tags=["runs"], response_model=OpenAIRun)
-def create_thread_and_run(
-    request: CreateThreadRunRequest = Body(...),
-):
-    # TODO: add a bunch of messages and execute
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.get("/{thread_id}/runs", tags=["runs"], response_model=List[OpenAIRun])
-def list_runs(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    limit: int = Query(1000, description="How many runs to retrieve."),
-    order: str = Query("asc", description="Order of runs to retrieve (either 'asc' or 'desc')."),
-    after: str = Query(None, description="A cursor for use in pagination. `after` is an object ID that defines your place in the list."),
-    before: str = Query(None, description="A cursor for use in pagination. `after` is an object ID that defines your place in the list."),
-):
-    # TODO: store run information in a DB so it can be returned here
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.get("/{thread_id}/runs/{run_id}/steps", tags=["runs"], response_model=List[OpenAIRunStep])
-def list_run_steps(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    run_id: str = Path(..., description="The unique identifier of the run."),
-    limit: int = Query(1000, description="How many run steps to retrieve."),
-    order: str = Query("asc", description="Order of run steps to retrieve (either 'asc' or 'desc')."),
-    after: str = Query(None, description="A cursor for use in pagination. `after` is an object ID that defines your place in the list."),
-    before: str = Query(None, description="A cursor for use in pagination. `after` is an object ID that defines your place in the list."),
-):
-    # TODO: store run information in a DB so it can be returned here
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.get("/{thread_id}/runs/{run_id}", tags=["runs"], response_model=OpenAIRun)
-def retrieve_run(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    run_id: str = Path(..., description="The unique identifier of the run."),
-):
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.get("/{thread_id}/runs/{run_id}/steps/{step_id}", tags=["runs"], response_model=OpenAIRunStep)
-def retrieve_run_step(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    run_id: str = Path(..., description="The unique identifier of the run."),
-    step_id: str = Path(..., description="The unique identifier of the run step."),
-):
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.post("/{thread_id}/runs/{run_id}", tags=["runs"], response_model=OpenAIRun)
-def modify_run(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    run_id: str = Path(..., description="The unique identifier of the run."),
-    request: ModifyRunRequest = Body(...),
-):
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.post("/{thread_id}/runs/{run_id}/submit_tool_outputs", tags=["runs"], response_model=OpenAIRun)
-def submit_tool_outputs_to_run(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    run_id: str = Path(..., description="The unique identifier of the run."),
-    request: SubmitToolOutputsToRunRequest = Body(...),
-):
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")
-
-
-@router.post("/{thread_id}/runs/{run_id}/cancel", tags=["runs"], response_model=OpenAIRun)
-def cancel_run(
-    thread_id: str = Path(..., description="The unique identifier of the thread."),
-    run_id: str = Path(..., description="The unique identifier of the run."),
-):
-    raise HTTPException(status_code=404, detail="Not yet implemented (coming soon)")

letta/services/agents_tags_manager.py

@@ -1,64 +0,0 @@
-from typing import List
-
-from letta.orm.agents_tags import AgentsTags as AgentsTagsModel
-from letta.orm.errors import NoResultFound
-from letta.schemas.agents_tags import AgentsTags as PydanticAgentsTags
-from letta.schemas.user import User as PydanticUser
-from letta.utils import enforce_types
-
-
-class AgentsTagsManager:
-    """Manager class to handle business logic related to Tags."""
-
-    def __init__(self):
-        from letta.server.server import db_context
-
-        self.session_maker = db_context
-
-    @enforce_types
-    def add_tag_to_agent(self, agent_id: str, tag: str, actor: PydanticUser) -> PydanticAgentsTags:
-        """Add a tag to an agent."""
-        with self.session_maker() as session:
-            # Check if the tag already exists for this agent
-            try:
-                agents_tags_model = AgentsTagsModel.read(db_session=session, agent_id=agent_id, tag=tag, actor=actor)
-                return agents_tags_model.to_pydantic()
-            except NoResultFound:
-                agents_tags = PydanticAgentsTags(agent_id=agent_id, tag=tag).model_dump(exclude_none=True)
-                new_tag = AgentsTagsModel(**agents_tags, organization_id=actor.organization_id)
-                new_tag.create(session, actor=actor)
-                return new_tag.to_pydantic()
-
-    @enforce_types
-    def delete_all_tags_from_agent(self, agent_id: str, actor: PydanticUser):
-        """Delete a tag from an agent. This is a permanent hard delete."""
-        tags = self.get_tags_for_agent(agent_id=agent_id, actor=actor)
-        for tag in tags:
-            self.delete_tag_from_agent(agent_id=agent_id, tag=tag, actor=actor)
-
-    @enforce_types
-    def delete_tag_from_agent(self, agent_id: str, tag: str, actor: PydanticUser):
-        """Delete a tag from an agent."""
-        with self.session_maker() as session:
-            try:
-                # Retrieve and delete the tag association
-                tag_association = AgentsTagsModel.read(db_session=session, agent_id=agent_id, tag=tag, actor=actor)
-                tag_association.hard_delete(session, actor=actor)
-            except NoResultFound:
-                raise ValueError(f"Tag '{tag}' not found for agent '{agent_id}'.")
-
-    @enforce_types
-    def get_agents_by_tag(self, tag: str, actor: PydanticUser) -> List[str]:
-        """Retrieve all agent IDs associated with a specific tag."""
-        with self.session_maker() as session:
-            # Query for all agents with the given tag
-            agents_with_tag = AgentsTagsModel.list(db_session=session, tag=tag, organization_id=actor.organization_id)
-            return [record.agent_id for record in agents_with_tag]
-
-    @enforce_types
-    def get_tags_for_agent(self, agent_id: str, actor: PydanticUser) -> List[str]:
-        """Retrieve all tags associated with a specific agent."""
-        with self.session_maker() as session:
-            # Query for all tags associated with the given agent
-            tags_for_agent = AgentsTagsModel.list(db_session=session, agent_id=agent_id, organization_id=actor.organization_id)
-            return [record.tag for record in tags_for_agent]

letta/services/blocks_agents_manager.py

@@ -1,106 +0,0 @@
-import warnings
-from typing import List
-
-from letta.orm.blocks_agents import BlocksAgents as BlocksAgentsModel
-from letta.orm.errors import NoResultFound
-from letta.schemas.blocks_agents import BlocksAgents as PydanticBlocksAgents
-from letta.utils import enforce_types
-
-
-# TODO: DELETE THIS ASAP
-# TODO: So we have a patch where we manually specify CRUD operations
-# TODO: This is because Agent is NOT migrated to the ORM yet
-# TODO: Once we migrate Agent to the ORM, we should deprecate any agents relationship table managers
-class BlocksAgentsManager:
-    """Manager class to handle business logic related to Blocks and Agents."""
-
-    def __init__(self):
-        from letta.server.server import db_context
-
-        self.session_maker = db_context
-
-    @enforce_types
-    def add_block_to_agent(self, agent_id: str, block_id: str, block_label: str) -> PydanticBlocksAgents:
-        """Add a block to an agent. If the label already exists on that agent, this will error."""
-        with self.session_maker() as session:
-            try:
-                # Check if the block-label combination already exists for this agent
-                blocks_agents_record = BlocksAgentsModel.read(db_session=session, agent_id=agent_id, block_label=block_label)
-                warnings.warn(f"Block label '{block_label}' already exists for agent '{agent_id}'.")
-            except NoResultFound:
-                blocks_agents_record = PydanticBlocksAgents(agent_id=agent_id, block_id=block_id, block_label=block_label)
-                blocks_agents_record = BlocksAgentsModel(**blocks_agents_record.model_dump(exclude_none=True))
-                blocks_agents_record.create(session)
-
-            return blocks_agents_record.to_pydantic()
-
-    @enforce_types
-    def remove_block_with_label_from_agent(self, agent_id: str, block_label: str) -> PydanticBlocksAgents:
-        """Remove a block with a label from an agent."""
-        with self.session_maker() as session:
-            try:
-                # Find and delete the block-label association for the agent
-                blocks_agents_record = BlocksAgentsModel.read(db_session=session, agent_id=agent_id, block_label=block_label)
-                blocks_agents_record.hard_delete(session)
-                return blocks_agents_record.to_pydantic()
-            except NoResultFound:
-                raise ValueError(f"Block label '{block_label}' not found for agent '{agent_id}'.")
-
-    @enforce_types
-    def remove_block_with_id_from_agent(self, agent_id: str, block_id: str) -> PydanticBlocksAgents:
-        """Remove a block with a label from an agent."""
-        with self.session_maker() as session:
-            try:
-                # Find and delete the block-label association for the agent
-                blocks_agents_record = BlocksAgentsModel.read(db_session=session, agent_id=agent_id, block_id=block_id)
-                blocks_agents_record.hard_delete(session)
-                return blocks_agents_record.to_pydantic()
-            except NoResultFound:
-                raise ValueError(f"Block id '{block_id}' not found for agent '{agent_id}'.")
-
-    @enforce_types
-    def update_block_id_for_agent(self, agent_id: str, block_label: str, new_block_id: str) -> PydanticBlocksAgents:
-        """Update the block ID for a specific block label for an agent."""
-        with self.session_maker() as session:
-            try:
-                blocks_agents_record = BlocksAgentsModel.read(db_session=session, agent_id=agent_id, block_label=block_label)
-                blocks_agents_record.block_id = new_block_id
-                return blocks_agents_record.to_pydantic()
-            except NoResultFound:
-                raise ValueError(f"Block label '{block_label}' not found for agent '{agent_id}'.")
-
-    @enforce_types
-    def list_block_ids_for_agent(self, agent_id: str) -> List[str]:
-        """List all block ids associated with a specific agent."""
-        with self.session_maker() as session:
-            blocks_agents_record = BlocksAgentsModel.list(db_session=session, agent_id=agent_id)
-            return [record.block_id for record in blocks_agents_record]
-
-    @enforce_types
-    def list_block_labels_for_agent(self, agent_id: str) -> List[str]:
-        """List all block labels associated with a specific agent."""
-        with self.session_maker() as session:
-            blocks_agents_record = BlocksAgentsModel.list(db_session=session, agent_id=agent_id)
-            return [record.block_label for record in blocks_agents_record]
-
-    @enforce_types
-    def list_agent_ids_with_block(self, block_id: str) -> List[str]:
-        """List all agents associated with a specific block."""
-        with self.session_maker() as session:
-            blocks_agents_record = BlocksAgentsModel.list(db_session=session, block_id=block_id)
-            return [record.agent_id for record in blocks_agents_record]
-
-    @enforce_types
-    def get_block_id_for_label(self, agent_id: str, block_label: str) -> str:
-        """Get the block ID for a specific block label for an agent."""
-        with self.session_maker() as session:
-            try:
-                blocks_agents_record = BlocksAgentsModel.read(db_session=session, agent_id=agent_id, block_label=block_label)
-                return blocks_agents_record.block_id
-            except NoResultFound:
-                raise ValueError(f"Block label '{block_label}' not found for agent '{agent_id}'.")
-
-    @enforce_types
-    def remove_all_agent_blocks(self, agent_id: str):
-        for block_id in self.list_block_ids_for_agent(agent_id):
-            self.remove_block_with_id_from_agent(agent_id, block_id)

letta/services/tools_agents_manager.py

@@ -1,94 +0,0 @@
-import warnings
-from typing import List, Optional
-
-from sqlalchemy import select
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.orm import Session
-
-from letta.orm.errors import NoResultFound
-from letta.orm.organization import Organization
-from letta.orm.tool import Tool
-from letta.orm.tools_agents import ToolsAgents as ToolsAgentsModel
-from letta.schemas.tools_agents import ToolsAgents as PydanticToolsAgents
-
-class ToolsAgentsManager:
-    """Manages the relationship between tools and agents."""
-
-    def __init__(self):
-        from letta.server.server import db_context
-        self.session_maker = db_context
-
-    def add_tool_to_agent(self, agent_id: str, tool_id: str, tool_name: str) -> PydanticToolsAgents:
-        """Add a tool to an agent.
-        
-        When a tool is added to an agent, it will be added to all agents in the same organization.
-        """
-        with self.session_maker() as session:
-            try:
-                # Check if the tool-agent combination already exists for this agent
-                tools_agents_record = ToolsAgentsModel.read(db_session=session, agent_id=agent_id, tool_name=tool_name)
-                warnings.warn(f"Tool name '{tool_name}' already exists for agent '{agent_id}'.")
-            except NoResultFound:
-                tools_agents_record = PydanticToolsAgents(agent_id=agent_id, tool_id=tool_id, tool_name=tool_name)
-                tools_agents_record = ToolsAgentsModel(**tools_agents_record.model_dump(exclude_none=True))
-                tools_agents_record.create(session)
-
-            return tools_agents_record.to_pydantic()
-
-    def remove_tool_with_name_from_agent(self, agent_id: str, tool_name: str) -> None:
-        """Remove a tool from an agent by its name.
-        
-        When a tool is removed from an agent, it will be removed from all agents in the same organization.
-        """
-        with self.session_maker() as session:
-            try:
-                # Find and delete the tool-agent association for the agent
-                tools_agents_record = ToolsAgentsModel.read(db_session=session, agent_id=agent_id, tool_name=tool_name)
-                tools_agents_record.hard_delete(session)
-                return tools_agents_record.to_pydantic()
-            except NoResultFound:
-                raise ValueError(f"Tool name '{tool_name}' not found for agent '{agent_id}'.")
-
-    def remove_tool_with_id_from_agent(self, agent_id: str, tool_id: str) -> PydanticToolsAgents:
-        """Remove a tool with an ID from an agent."""
-        with self.session_maker() as session:
-            try:
-                tools_agents_record = ToolsAgentsModel.read(db_session=session, agent_id=agent_id, tool_id=tool_id)
-                tools_agents_record.hard_delete(session)
-                return tools_agents_record.to_pydantic()
-            except NoResultFound:
-                raise ValueError(f"Tool ID '{tool_id}' not found for agent '{agent_id}'.")
-
-    def list_tool_ids_for_agent(self, agent_id: str) -> List[str]:
-        """List all tool IDs associated with a specific agent."""
-        with self.session_maker() as session:
-            tools_agents_record = ToolsAgentsModel.list(db_session=session, agent_id=agent_id)
-            return [record.tool_id for record in tools_agents_record]
-
-    def list_tool_names_for_agent(self, agent_id: str) -> List[str]:
-        """List all tool names associated with a specific agent."""
-        with self.session_maker() as session:
-            tools_agents_record = ToolsAgentsModel.list(db_session=session, agent_id=agent_id)
-            return [record.tool_name for record in tools_agents_record]
-
-    def list_agent_ids_with_tool(self, tool_id: str) -> List[str]:
-        """List all agents associated with a specific tool."""
-        with self.session_maker() as session:
-            tools_agents_record = ToolsAgentsModel.list(db_session=session, tool_id=tool_id)
-            return [record.agent_id for record in tools_agents_record]
-
-    def get_tool_id_for_name(self, agent_id: str, tool_name: str) -> str:
-        """Get the tool ID for a specific tool name for an agent."""
-        with self.session_maker() as session:
-            try:
-                tools_agents_record = ToolsAgentsModel.read(db_session=session, agent_id=agent_id, tool_name=tool_name)
-                return tools_agents_record.tool_id
-            except NoResultFound:
-                raise ValueError(f"Tool name '{tool_name}' not found for agent '{agent_id}'.")
-
-    def remove_all_agent_tools(self, agent_id: str) -> None:
-        """Remove all tools associated with an agent."""
-        with self.session_maker() as session:
-            tools_agents_records = ToolsAgentsModel.list(db_session=session, agent_id=agent_id)
-            for record in tools_agents_records:
-                record.hard_delete(session)