letta-nightly 0.5.2.dev20241112104101__py3-none-any.whl → 0.5.2.dev20241113234401__py3-none-any.whl

letta/orm/source.py

@@ -0,0 +1,51 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from sqlalchemy import JSON, TypeDecorator
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.source import Source as PydanticSource
+
+if TYPE_CHECKING:
+    from letta.orm.organization import Organization
+
+
+class EmbeddingConfigColumn(TypeDecorator):
+    """Custom type for storing EmbeddingConfig as JSON"""
+
+    impl = JSON
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        return dialect.type_descriptor(JSON())
+
+    def process_bind_param(self, value, dialect):
+        if value:
+            # return vars(value)
+            if isinstance(value, EmbeddingConfig):
+                return value.model_dump()
+        return value
+
+    def process_result_value(self, value, dialect):
+        if value:
+            return EmbeddingConfig(**value)
+        return value
+
+
+class Source(SqlalchemyBase, OrganizationMixin):
+    """A source represents an embedded text passage"""
+
+    __tablename__ = "sources"
+    __pydantic_model__ = PydanticSource
+
+    name: Mapped[str] = mapped_column(doc="the name of the source, must be unique within the org", nullable=False)
+    description: Mapped[str] = mapped_column(nullable=True, doc="a human-readable description of the source")
+    embedding_config: Mapped[EmbeddingConfig] = mapped_column(EmbeddingConfigColumn, doc="Configuration settings for embedding.")
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True, doc="metadata for the source.")
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="sources")
+    files: Mapped[List["Source"]] = relationship("FileMetadata", back_populates="source", cascade="all, delete-orphan")
+    # agents: Mapped[List["Agent"]] = relationship("Agent", secondary="sources_agents", back_populates="sources")

letta/orm/tool.py

@@ -28,7 +28,6 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     # An organization should not have multiple tools with the same name
     __table_args__ = (UniqueConstraint("name", "organization_id", name="uix_name_organization"),)
 
-    id: Mapped[str] = mapped_column(String, primary_key=True)
     name: Mapped[str] = mapped_column(doc="The display name of the tool.")
     description: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The description of the tool.")
     tags: Mapped[List] = mapped_column(JSON, doc="Metadata tags used to filter tools.")

letta/orm/user.py

@@ -1,6 +1,5 @@
 from typing import TYPE_CHECKING
 
-from sqlalchemy import String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import OrganizationMixin
@@ -17,7 +16,6 @@ class User(SqlalchemyBase, OrganizationMixin):
     __tablename__ = "users"
     __pydantic_model__ = PydanticUser
 
-    id: Mapped[str] = mapped_column(String, primary_key=True)
     name: Mapped[str] = mapped_column(nullable=False, doc="The display name of the user.")
 
     # relationships

letta/providers.py

@@ -462,7 +462,6 @@ class VLLMChatCompletionsProvider(Provider):
         response = openai_get_model_list(self.base_url, api_key=None)
 
         configs = []
-        print(response)
         for model in response["data"]:
             configs.append(
                 LLMConfig(

letta/schemas/file.py

@@ -4,7 +4,6 @@ from typing import Optional
 from pydantic import Field
 
 from letta.schemas.letta_base import LettaBase
-from letta.utils import get_utc_time
 
 
 class FileMetadataBase(LettaBase):
@@ -17,7 +16,7 @@ class FileMetadata(FileMetadataBase):
     """Representation of a single FileMetadata"""
 
     id: str = FileMetadataBase.generate_id_field()
-    user_id: str = Field(description="The unique identifier of the user associated with the document.")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the document.")
     source_id: str = Field(..., description="The unique identifier of the source associated with the document.")
     file_name: Optional[str] = Field(None, description="The name of the file.")
     file_path: Optional[str] = Field(None, description="The path to the file.")
@@ -25,7 +24,8 @@ class FileMetadata(FileMetadataBase):
     file_size: Optional[int] = Field(None, description="The size of the file in bytes.")
     file_creation_date: Optional[str] = Field(None, description="The creation date of the file.")
     file_last_modified_date: Optional[str] = Field(None, description="The last modified date of the file.")
-    created_at: datetime = Field(default_factory=get_utc_time, description="The creation date of this file metadata object.")
 
-    class Config:
-        extra = "allow"
+    # orm metadata, optional fields
+    created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The creation date of the file.")
+    updated_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The update date of the file.")
+    is_deleted: bool = Field(False, description="Whether this file is deleted or not.")

letta/schemas/source.py

@@ -1,12 +1,10 @@
 from datetime import datetime
 from typing import Optional
 
-from fastapi import UploadFile
-from pydantic import BaseModel, Field
+from pydantic import Field
 
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import LettaBase
-from letta.utils import get_utc_time
 
 
 class BaseSource(LettaBase):
@@ -15,15 +13,6 @@ class BaseSource(LettaBase):
     """
 
     __id_prefix__ = "source"
-    description: Optional[str] = Field(None, description="The description of the source.")
-    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the passage.")
-    # NOTE: .metadata is a reserved attribute on SQLModel
-    metadata_: Optional[dict] = Field(None, description="Metadata associated with the source.")
-
-
-class SourceCreate(BaseSource):
-    name: str = Field(..., description="The name of the source.")
-    description: Optional[str] = Field(None, description="The description of the source.")
 
 
 class Source(BaseSource):
@@ -34,7 +23,6 @@ class Source(BaseSource):
         id (str): The ID of the source
         name (str): The name of the source.
         embedding_config (EmbeddingConfig): The embedding configuration used by the source.
-        created_at (datetime): The creation date of the source.
         user_id (str): The ID of the user that created the source.
         metadata_ (dict): Metadata associated with the source.
         description (str): The description of the source.
@@ -42,21 +30,39 @@ class Source(BaseSource):
 
     id: str = BaseSource.generate_id_field()
     name: str = Field(..., description="The name of the source.")
+    description: Optional[str] = Field(None, description="The description of the source.")
     embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the source.")
-    created_at: datetime = Field(default_factory=get_utc_time, description="The creation date of the source.")
-    user_id: str = Field(..., description="The ID of the user that created the source.")
+    organization_id: Optional[str] = Field(None, description="The ID of the organization that created the source.")
+    metadata_: Optional[dict] = Field(None, description="Metadata associated with the source.")
 
+    # metadata fields
+    created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
+    last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
+    created_at: Optional[datetime] = Field(None, description="The timestamp when the source was created.")
+    updated_at: Optional[datetime] = Field(None, description="The timestamp when the source was last updated.")
 
-class SourceUpdate(BaseSource):
-    id: str = Field(..., description="The ID of the source.")
-    name: Optional[str] = Field(None, description="The name of the source.")
 
+class SourceCreate(BaseSource):
+    """
+    Schema for creating a new Source.
+    """
+
+    # required
+    name: str = Field(..., description="The name of the source.")
+    # TODO: @matt, make this required after shub makes the FE changes
+    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the source.")
+
+    # optional
+    description: Optional[str] = Field(None, description="The description of the source.")
+    metadata_: Optional[dict] = Field(None, description="Metadata associated with the source.")
 
-class UploadFileToSourceRequest(BaseModel):
-    file: UploadFile = Field(..., description="The file to upload.")
 
+class SourceUpdate(BaseSource):
+    """
+    Schema for updating an existing Source.
+    """
 
-class UploadFileToSourceResponse(BaseModel):
-    source: Source = Field(..., description="The source the file was uploaded to.")
-    added_passages: int = Field(..., description="The number of passages added to the source.")
-    added_documents: int = Field(..., description="The number of files added to the source.")
+    name: Optional[str] = Field(None, description="The name of the source.")
+    description: Optional[str] = Field(None, description="The description of the source.")
+    metadata_: Optional[dict] = Field(None, description="Metadata associated with the source.")
+    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the source.")

letta/server/rest_api/app.py

@@ -6,6 +6,8 @@ from typing import Optional
 
 import uvicorn
 from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.middleware.cors import CORSMiddleware
 
 from letta.__init__ import __version__
@@ -94,6 +96,27 @@ def generate_openapi_schema(app: FastAPI):
         Path(f"openapi_{name}.json").write_text(json.dumps(docs, indent=2))
 
 
+# middleware that only allows requests to pass through if user provides a password thats randomly generated and stored in memory
+def generate_password():
+    import secrets
+
+    return secrets.token_urlsafe(16)
+
+
+random_password = generate_password()
+
+
+class CheckPasswordMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        if request.headers.get("X-BARE-PASSWORD") == f"password {random_password}":
+            return await call_next(request)
+
+        return JSONResponse(
+            content={"detail": "Unauthorized"},
+            status_code=401,
+        )
+
+
 def create_application() -> "FastAPI":
     """the application start routine"""
     # global server
@@ -113,6 +136,10 @@ def create_application() -> "FastAPI":
         settings.cors_origins.append("https://app.letta.com")
         print(f"▶ View using ADE at: https://app.letta.com/local-project/agents")
 
+    if "--secure" in sys.argv:
+        print(f"▶ Using secure mode with password: {random_password}")
+        app.add_middleware(CheckPasswordMiddleware)
+
     app.add_middleware(
         CORSMiddleware,
         allow_origins=settings.cors_origins,

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

@@ -36,7 +36,7 @@ def get_source(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    return server.get_source(source_id=source_id, user_id=actor.id)
+    return server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
 
 
 @router.get("/name/{source_name}", response_model=str, operation_id="get_source_id_by_name")
@@ -50,8 +50,8 @@ def get_source_id_by_name(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    source_id = server.get_source_id(source_name=source_name, user_id=actor.id)
-    return source_id
+    source = server.source_manager.get_source_by_name(source_name=source_name, actor=actor)
+    return source.id
 
 
 @router.get("/", response_model=List[Source], operation_id="list_sources")
@@ -64,12 +64,12 @@ def list_sources(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    return server.list_all_sources(user_id=actor.id)
+    return server.list_all_sources(actor=actor)
 
 
 @router.post("/", response_model=Source, operation_id="create_source")
 def create_source(
-    source: SourceCreate,
+    source_create: SourceCreate,
     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
 ):
@@ -77,8 +77,9 @@ def create_source(
     Create a new data source.
     """
     actor = server.get_user_or_default(user_id=user_id)
+    source = Source(**source_create.model_dump())
 
-    return server.create_source(request=source, user_id=actor.id)
+    return server.source_manager.create_source(source=source, actor=actor)
 
 
 @router.patch("/{source_id}", response_model=Source, operation_id="update_source")
@@ -92,10 +93,7 @@ def update_source(
     Update the name or documentation of an existing data source.
     """
     actor = server.get_user_or_default(user_id=user_id)
-
-    assert source.id == source_id, "Source ID in path must match ID in request body"
-
-    return server.update_source(request=source, user_id=actor.id)
+    return server.source_manager.update_source(source_id=source_id, source_update=source, actor=actor)
 
 
 @router.delete("/{source_id}", response_model=None, operation_id="delete_source")
@@ -109,7 +107,7 @@ def delete_source(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    server.delete_source(source_id=source_id, user_id=actor.id)
+    server.delete_source(source_id=source_id, actor=actor)
 
 
 @router.post("/{source_id}/attach", response_model=Source, operation_id="attach_agent_to_source")
@@ -124,7 +122,7 @@ def attach_source_to_agent(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    source = server.ms.get_source(source_id=source_id, user_id=actor.id)
+    source = server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
     assert source is not None, f"Source with id={source_id} not found."
     source = server.attach_source_to_agent(source_id=source.id, agent_id=agent_id, user_id=actor.id)
     return source
@@ -158,7 +156,7 @@ def upload_file_to_source(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    source = server.ms.get_source(source_id=source_id, user_id=actor.id)
+    source = server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
     assert source is not None, f"Source with id={source_id} not found."
     bytes = file.file.read()
 
@@ -200,11 +198,13 @@ def list_files_from_source(
     limit: int = Query(1000, description="Number of files to return"),
     cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
     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
 ):
     """
     List paginated files associated with a data source.
     """
-    return server.list_files_from_source(source_id=source_id, limit=limit, cursor=cursor)
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.source_manager.list_files(source_id=source_id, limit=limit, cursor=cursor, actor=actor)
 
 
 # it's redundant to include /delete in the URL path. The HTTP verb DELETE already implies that action.
@@ -221,7 +221,7 @@ def delete_file_from_source(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    deleted_file = server.delete_file_from_source(source_id=source_id, file_id=file_id, user_id=actor.id)
+    deleted_file = server.source_manager.delete_file(file_id=file_id, actor=actor)
     if deleted_file is None:
         raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
 

letta/server/server.py

@@ -65,7 +65,6 @@ from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
 from letta.schemas.enums import JobStatus
-from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.letta_message import LettaMessage
 from letta.schemas.llm_config import LLMConfig
@@ -78,12 +77,13 @@ from letta.schemas.memory import (
 from letta.schemas.message import Message, MessageCreate, MessageRole, UpdateMessage
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
-from letta.schemas.source import Source, SourceCreate, SourceUpdate
+from letta.schemas.source import Source
 from letta.schemas.tool import Tool, ToolCreate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.services.agents_tags_manager import AgentsTagsManager
 from letta.services.organization_manager import OrganizationManager
+from letta.services.source_manager import SourceManager
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
 from letta.utils import create_random_username, json_dumps, json_loads
@@ -249,6 +249,7 @@ class SyncServer(Server):
         self.organization_manager = OrganizationManager()
         self.user_manager = UserManager()
         self.tool_manager = ToolManager()
+        self.source_manager = SourceManager()
         self.agents_tags_manager = AgentsTagsManager()
 
         # Make default user and org
@@ -1511,12 +1512,16 @@ class SyncServer(Server):
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
 
-        # Verify that the agent exists and is owned by the user
+        # Verify that the agent exists and belongs to the org of the user
         agent_state = self.ms.get_agent(agent_id=agent_id, user_id=user_id)
         if not agent_state:
             raise ValueError(f"Could not find agent_id={agent_id} under user_id={user_id}")
-        if agent_state.user_id != user_id:
-            raise ValueError(f"Could not authorize agent_id={agent_id} with user_id={user_id}")
+
+        agent_state_user = self.user_manager.get_user_by_id(user_id=agent_state.user_id)
+        if agent_state_user.organization_id != actor.organization_id:
+            raise ValueError(
+                f"Could not authorize agent_id={agent_id} with user_id={user_id} because of differing organizations; agent_id was created in {agent_state_user.organization_id} while user belongs to {actor.organization_id}. How did they get the agent id?"
+            )
 
         # First, if the agent is in the in-memory cache we should remove it
         # List of {'user_id': user_id, 'agent_id': agent_id, 'agent': agent_obj} dicts
@@ -1560,44 +1565,12 @@ class SyncServer(Server):
         self.ms.delete_api_key(api_key=api_key)
         return api_key_obj
 
-    def create_source(self, request: SourceCreate, user_id: str) -> Source:  # TODO: add other fields
-        """Create a new data source"""
-        source = Source(
-            name=request.name,
-            user_id=user_id,
-            embedding_config=self.list_embedding_models()[0],  # TODO: require providing this
-        )
-        self.ms.create_source(source)
-        assert self.ms.get_source(source_name=request.name, user_id=user_id) is not None, f"Failed to create source {request.name}"
-        return source
-
-    def update_source(self, request: SourceUpdate, user_id: str) -> Source:
-        """Update an existing data source"""
-        if not request.id:
-            existing_source = self.ms.get_source(source_name=request.name, user_id=user_id)
-        else:
-            existing_source = self.ms.get_source(source_id=request.id)
-        if not existing_source:
-            raise ValueError("Source does not exist")
-
-        # override updated fields
-        if request.name:
-            existing_source.name = request.name
-        if request.metadata_:
-            existing_source.metadata_ = request.metadata_
-        if request.description:
-            existing_source.description = request.description
-
-        self.ms.update_source(existing_source)
-        return existing_source
-
-    def delete_source(self, source_id: str, user_id: str):
+    def delete_source(self, source_id: str, actor: User):
         """Delete a data source"""
-        source = self.ms.get_source(source_id=source_id, user_id=user_id)
-        self.ms.delete_source(source_id)
+        self.source_manager.delete_source(source_id=source_id, actor=actor)
 
         # delete data from passage store
-        passage_store = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
+        passage_store = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=actor.id)
         passage_store.delete({"source_id": source_id})
 
         # TODO: delete data from agent passage stores (?)
@@ -1639,9 +1612,9 @@ class SyncServer(Server):
         # try:
         from letta.data_sources.connectors import DirectoryConnector
 
-        source = self.ms.get_source(source_id=source_id)
+        source = self.source_manager.get_source_by_id(source_id=source_id)
         connector = DirectoryConnector(input_files=[file_path])
-        num_passages, num_documents = self.load_data(user_id=source.user_id, source_name=source.name, connector=connector)
+        num_passages, num_documents = self.load_data(user_id=source.created_by_id, source_name=source.name, connector=connector)
         # except Exception as e:
         #    # job failed with error
         #    error = str(e)
@@ -1662,9 +1635,6 @@ class SyncServer(Server):
 
         return job
 
-    def delete_file_from_source(self, source_id: str, file_id: str, user_id: Optional[str]) -> Optional[FileMetadata]:
-        return self.ms.delete_file_from_source(source_id=source_id, file_id=file_id, user_id=user_id)
-
     def load_data(
         self,
         user_id: str,
@@ -1675,16 +1645,16 @@ class SyncServer(Server):
         # TODO: this should be implemented as a batch job or at least async, since it may take a long time
 
         # load data from a data source into the document store
-        source = self.ms.get_source(source_name=source_name, user_id=user_id)
+        user = self.user_manager.get_user_by_id(user_id=user_id)
+        source = self.source_manager.get_source_by_name(source_name=source_name, actor=user)
         if source is None:
             raise ValueError(f"Data source {source_name} does not exist for user {user_id}")
 
         # get the data connectors
         passage_store = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
-        file_store = StorageConnector.get_storage_connector(TableType.FILES, self.config, user_id=user_id)
 
         # load data into the document store
-        passage_count, document_count = load_data(connector, source, passage_store, file_store)
+        passage_count, document_count = load_data(connector, source, passage_store, self.source_manager, actor=user)
         return passage_count, document_count
 
     def attach_source_to_agent(
@@ -1696,10 +1666,13 @@ class SyncServer(Server):
         source_name: Optional[str] = None,
     ) -> Source:
         # attach a data source to an agent
-        data_source = self.ms.get_source(source_id=source_id, user_id=user_id, source_name=source_name)
-        if data_source is None:
-            raise ValueError(f"Data source id={source_id} name={source_name} does not exist for user_id {user_id}")
-
+        user = self.user_manager.get_user_by_id(user_id=user_id)
+        if source_id:
+            data_source = self.source_manager.get_source_by_id(source_id=source_id, actor=user)
+        elif source_name:
+            data_source = self.source_manager.get_source_by_name(source_name=source_name, actor=user)
+        else:
+            raise ValueError(f"Need to provide at least source_id or source_name to find the source.")
         # get connection to data source storage
         source_connector = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
 
@@ -1719,12 +1692,14 @@ class SyncServer(Server):
         source_id: Optional[str] = None,
         source_name: Optional[str] = None,
     ) -> Source:
-        if not source_id:
-            assert source_name is not None, "source_name must be provided if source_id is not"
-            source = self.ms.get_source(source_name=source_name, user_id=user_id)
-            source_id = source.id
+        user = self.user_manager.get_user_by_id(user_id=user_id)
+        if source_id:
+            source = self.source_manager.get_source_by_id(source_id=source_id, actor=user)
+        elif source_name:
+            source = self.source_manager.get_source_by_name(source_name=source_name, actor=user)
         else:
-            source = self.ms.get_source(source_id=source_id)
+            raise ValueError(f"Need to provide at least source_id or source_name to find the source.")
+        source_id = source.id
 
         # delete all Passage objects with source_id==source_id from agent's archival memory
         agent = self._get_or_load_agent(agent_id=agent_id)
@@ -1739,27 +1714,25 @@ class SyncServer(Server):
 
     def list_attached_sources(self, agent_id: str) -> List[Source]:
         # list all attached sources to an agent
-        return self.ms.list_attached_sources(agent_id)
+        source_ids = self.ms.list_attached_source_ids(agent_id)
 
-    def list_files_from_source(self, source_id: str, limit: int = 1000, cursor: Optional[str] = None) -> List[FileMetadata]:
-        # list all attached sources to an agent
-        return self.ms.list_files_from_source(source_id=source_id, limit=limit, cursor=cursor)
+        return [self.source_manager.get_source_by_id(source_id=id) for id in source_ids]
 
     def list_data_source_passages(self, user_id: str, source_id: str) -> List[Passage]:
         warnings.warn("list_data_source_passages is not yet implemented, returning empty list.", category=UserWarning)
         return []
 
-    def list_all_sources(self, user_id: str) -> List[Source]:
+    def list_all_sources(self, actor: User) -> List[Source]:
         """List all sources (w/ extra metadata) belonging to a user"""
 
-        sources = self.ms.list_sources(user_id=user_id)
+        sources = self.source_manager.list_sources(actor=actor)
 
         # Add extra metadata to the sources
         sources_with_metadata = []
         for source in sources:
 
             # count number of passages
-            passage_conn = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
+            passage_conn = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=actor.id)
             num_passages = passage_conn.size({"source_id": source.id})
 
             # TODO: add when files table implemented
@@ -1773,7 +1746,7 @@ class SyncServer(Server):
             attached_agents = [
                 {
                     "id": str(a_id),
-                    "name": self.ms.get_agent(user_id=user_id, agent_id=a_id).name,
+                    "name": self.ms.get_agent(user_id=actor.id, agent_id=a_id).name,
                 }
                 for a_id in agent_ids
             ]

letta/services/organization_manager.py

@@ -27,18 +27,26 @@ class OrganizationManager:
         return self.get_organization_by_id(self.DEFAULT_ORG_ID)
 
     @enforce_types
-    def get_organization_by_id(self, org_id: str) -> PydanticOrganization:
+    def get_organization_by_id(self, org_id: str) -> Optional[PydanticOrganization]:
         """Fetch an organization by ID."""
         with self.session_maker() as session:
             try:
                 organization = OrganizationModel.read(db_session=session, identifier=org_id)
                 return organization.to_pydantic()
             except NoResultFound:
-                raise ValueError(f"Organization with id {org_id} not found.")
+                return None
 
     @enforce_types
     def create_organization(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
         """Create a new organization. If a name is provided, it is used, otherwise, a random one is generated."""
+        org = self.get_organization_by_id(pydantic_org.id)
+        if org:
+            return org
+        else:
+            return self._create_organization(pydantic_org=pydantic_org)
+
+    @enforce_types
+    def _create_organization(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
         with self.session_maker() as session:
             org = OrganizationModel(**pydantic_org.model_dump())
             org.create(session)
@@ -47,16 +55,7 @@ class OrganizationManager:
     @enforce_types
     def create_default_organization(self) -> PydanticOrganization:
         """Create the default organization."""
-        with self.session_maker() as session:
-            # Try to get it first
-            try:
-                org = OrganizationModel.read(db_session=session, identifier=self.DEFAULT_ORG_ID)
-            # If it doesn't exist, make it
-            except NoResultFound:
-                org = OrganizationModel(name=self.DEFAULT_ORG_NAME, id=self.DEFAULT_ORG_ID)
-                org.create(session)
-
-            return org.to_pydantic()
+        return self.create_organization(PydanticOrganization(name=self.DEFAULT_ORG_NAME, id=self.DEFAULT_ORG_ID))
 
     @enforce_types
     def update_organization_name_using_id(self, org_id: str, name: Optional[str] = None) -> PydanticOrganization:
@@ -73,7 +72,7 @@ class OrganizationManager:
         """Delete an organization by marking it as deleted."""
         with self.session_maker() as session:
             organization = OrganizationModel.read(db_session=session, identifier=org_id)
-            organization.delete(session)
+            organization.hard_delete(session)
 
     @enforce_types
     def list_organizations(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticOrganization]: