letta-nightly 0.11.7.dev20251007104119__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

letta/services/organization_manager.py

@@ -18,14 +18,6 @@ class OrganizationManager:
         """Fetch the default organization."""
         return await self.get_organization_by_id_async(DEFAULT_ORG_ID)
 
-    @enforce_types
-    @trace_method
-    def get_organization_by_id(self, org_id: str) -> Optional[PydanticOrganization]:
-        """Fetch an organization by ID."""
-        with db_registry.session() as session:
-            organization = OrganizationModel.read(db_session=session, identifier=org_id)
-            return organization.to_pydantic()
-
     @enforce_types
     @trace_method
     async def get_organization_by_id_async(self, org_id: str) -> Optional[PydanticOrganization]:
@@ -34,19 +26,6 @@ class OrganizationManager:
             organization = await OrganizationModel.read_async(db_session=session, identifier=org_id)
             return organization.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def create_organization(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
-        """Create the default organization."""
-        with db_registry.session() as session:
-            try:
-                organization = OrganizationModel.read(db_session=session, identifier=pydantic_org.id)
-                return organization.to_pydantic()
-            except:
-                organization = OrganizationModel(**pydantic_org.model_dump(to_orm=True))
-                organization = organization.create(session)
-                return organization.to_pydantic()
-
     @enforce_types
     @trace_method
     async def create_organization_async(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
@@ -65,13 +44,6 @@ class OrganizationManager:
             await org.create_async(session)
             return org.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def create_default_organization(self) -> PydanticOrganization:
-        """Create the default organization."""
-        pydantic_org = PydanticOrganization(name=DEFAULT_ORG_NAME, id=DEFAULT_ORG_ID)
-        return self.create_organization(pydantic_org)
-
     @enforce_types
     @trace_method
     async def create_default_organization_async(self) -> PydanticOrganization:
@@ -102,14 +74,6 @@ class OrganizationManager:
             await org.update_async(session)
             return org.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def delete_organization_by_id(self, org_id: str):
-        """Delete an organization by marking it as deleted."""
-        with db_registry.session() as session:
-            organization = OrganizationModel.read(db_session=session, identifier=org_id)
-            organization.hard_delete(session)
-
     @enforce_types
     @trace_method
     async def delete_organization_by_id_async(self, org_id: str):

letta/services/passage_manager.py

@@ -93,17 +93,6 @@ class PassageManager:
         return created_tags
 
     # AGENT PASSAGE METHODS
-    @enforce_types
-    @trace_method
-    def get_agent_passage_by_id(self, passage_id: str, actor: PydanticUser) -> Optional[PydanticPassage]:
-        """Fetch an agent passage by ID."""
-        with db_registry.session() as session:
-            try:
-                passage = ArchivalPassage.read(db_session=session, identifier=passage_id, actor=actor)
-                return passage.to_pydantic()
-            except NoResultFound:
-                raise NoResultFound(f"Agent passage with id {passage_id} not found in database.")
-
     @enforce_types
     @trace_method
     async def get_agent_passage_by_id_async(self, passage_id: str, actor: PydanticUser) -> Optional[PydanticPassage]:
@@ -116,17 +105,6 @@ class PassageManager:
                 raise NoResultFound(f"Agent passage with id {passage_id} not found in database.")
 
     # SOURCE PASSAGE METHODS
-    @enforce_types
-    @trace_method
-    def get_source_passage_by_id(self, passage_id: str, actor: PydanticUser) -> Optional[PydanticPassage]:
-        """Fetch a source passage by ID."""
-        with db_registry.session() as session:
-            try:
-                passage = SourcePassage.read(db_session=session, identifier=passage_id, actor=actor)
-                return passage.to_pydantic()
-            except NoResultFound:
-                raise NoResultFound(f"Source passage with id {passage_id} not found in database.")
-
     @enforce_types
     @trace_method
     async def get_source_passage_by_id_async(self, passage_id: str, actor: PydanticUser) -> Optional[PydanticPassage]:
@@ -138,32 +116,6 @@ class PassageManager:
             except NoResultFound:
                 raise NoResultFound(f"Source passage with id {passage_id} not found in database.")
 
-    # DEPRECATED - Use specific methods above
-    @enforce_types
-    @trace_method
-    def get_passage_by_id(self, passage_id: str, actor: PydanticUser) -> Optional[PydanticPassage]:
-        """DEPRECATED: Use get_agent_passage_by_id() or get_source_passage_by_id() instead."""
-        import warnings
-
-        warnings.warn(
-            "get_passage_by_id is deprecated. Use get_agent_passage_by_id() or get_source_passage_by_id() instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        with db_registry.session() as session:
-            # Try source passages first
-            try:
-                passage = SourcePassage.read(db_session=session, identifier=passage_id, actor=actor)
-                return passage.to_pydantic()
-            except NoResultFound:
-                # Try archival passages
-                try:
-                    passage = ArchivalPassage.read(db_session=session, identifier=passage_id, actor=actor)
-                    return passage.to_pydantic()
-                except NoResultFound:
-                    raise NoResultFound(f"Passage with id {passage_id} not found in database.")
-
     @enforce_types
     @trace_method
     async def get_passage_by_id_async(self, passage_id: str, actor: PydanticUser) -> Optional[PydanticPassage]:
@@ -189,40 +141,6 @@ class PassageManager:
                 except NoResultFound:
                     raise NoResultFound(f"Passage with id {passage_id} not found in database.")
 
-    @enforce_types
-    @trace_method
-    def create_agent_passage(self, pydantic_passage: PydanticPassage, actor: PydanticUser) -> PydanticPassage:
-        """Create a new agent passage."""
-        if not pydantic_passage.archive_id:
-            raise ValueError("Agent passage must have archive_id")
-        if pydantic_passage.source_id:
-            raise ValueError("Agent passage cannot have source_id")
-
-        data = pydantic_passage.model_dump(to_orm=True)
-
-        # Deduplicate tags if provided (for dual storage consistency)
-        tags = data.get("tags")
-        if tags:
-            tags = list(set(tags))
-
-        common_fields = {
-            "id": data.get("id"),
-            "text": data["text"],
-            "embedding": data["embedding"],
-            "embedding_config": data["embedding_config"],
-            "organization_id": data["organization_id"],
-            "metadata_": data.get("metadata", {}),
-            "tags": tags,
-            "is_deleted": data.get("is_deleted", False),
-            "created_at": data.get("created_at", datetime.now(timezone.utc)),
-        }
-        agent_fields = {"archive_id": data["archive_id"]}
-        passage = ArchivalPassage(**common_fields, **agent_fields)
-
-        with db_registry.session() as session:
-            passage.create(session, actor=actor)
-            return passage.to_pydantic()
-
     @enforce_types
     @trace_method
     async def create_agent_passage_async(self, pydantic_passage: PydanticPassage, actor: PydanticUser) -> PydanticPassage:
@@ -269,46 +187,6 @@ class PassageManager:
 
             return passage.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def create_source_passage(
-        self, pydantic_passage: PydanticPassage, file_metadata: PydanticFileMetadata, actor: PydanticUser
-    ) -> PydanticPassage:
-        """Create a new source passage."""
-        if not pydantic_passage.source_id:
-            raise ValueError("Source passage must have source_id")
-        if pydantic_passage.archive_id:
-            raise ValueError("Source passage cannot have archive_id")
-
-        data = pydantic_passage.model_dump(to_orm=True)
-
-        # Deduplicate tags if provided (for dual storage consistency)
-        tags = data.get("tags")
-        if tags:
-            tags = list(set(tags))
-
-        common_fields = {
-            "id": data.get("id"),
-            "text": data["text"],
-            "embedding": data["embedding"],
-            "embedding_config": data["embedding_config"],
-            "organization_id": data["organization_id"],
-            "metadata_": data.get("metadata", {}),
-            "tags": tags,
-            "is_deleted": data.get("is_deleted", False),
-            "created_at": data.get("created_at", datetime.now(timezone.utc)),
-        }
-        source_fields = {
-            "source_id": data["source_id"],
-            "file_id": data.get("file_id"),
-            "file_name": file_metadata.file_name,
-        }
-        passage = SourcePassage(**common_fields, **source_fields)
-
-        with db_registry.session() as session:
-            passage.create(session, actor=actor)
-            return passage.to_pydantic()
-
     @enforce_types
     @trace_method
     async def create_source_passage_async(
@@ -349,23 +227,6 @@ class PassageManager:
             passage = await passage.create_async(session, actor=actor)
             return passage.to_pydantic()
 
-    # DEPRECATED - Use specific methods above
-    @enforce_types
-    @trace_method
-    def create_passage(self, pydantic_passage: PydanticPassage, actor: PydanticUser) -> PydanticPassage:
-        """DEPRECATED: Use create_agent_passage() or create_source_passage() instead."""
-        import warnings
-
-        warnings.warn(
-            "create_passage is deprecated. Use create_agent_passage() or create_source_passage() instead.", DeprecationWarning, stacklevel=2
-        )
-
-        passage = self._preprocess_passage_for_creation(pydantic_passage=pydantic_passage)
-
-        with db_registry.session() as session:
-            passage.create(session, actor=actor)
-            return passage.to_pydantic()
-
     @enforce_types
     @trace_method
     async def create_passage_async(self, pydantic_passage: PydanticPassage, actor: PydanticUser) -> PydanticPassage:
@@ -654,34 +515,6 @@ class PassageManager:
         embeddings = await embedding_client.request_embeddings(text_chunks, embedding_config)
         return embeddings
 
-    @enforce_types
-    @trace_method
-    def update_agent_passage_by_id(
-        self, passage_id: str, passage: PydanticPassage, actor: PydanticUser, **kwargs
-    ) -> Optional[PydanticPassage]:
-        """Update an agent passage."""
-        if not passage_id:
-            raise ValueError("Passage ID must be provided.")
-
-        with db_registry.session() as session:
-            try:
-                curr_passage = ArchivalPassage.read(
-                    db_session=session,
-                    identifier=passage_id,
-                    actor=actor,
-                )
-            except NoResultFound:
-                raise ValueError(f"Agent passage with id {passage_id} does not exist.")
-
-            # Update the database record with values from the provided record
-            update_data = passage.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
-            for key, value in update_data.items():
-                setattr(curr_passage, key, value)
-
-            # Commit changes
-            curr_passage.update(session, actor=actor)
-            return curr_passage.to_pydantic()
-
     @enforce_types
     @trace_method
     async def update_agent_passage_by_id_async(
@@ -738,34 +571,6 @@ class PassageManager:
             await curr_passage.update_async(session, actor=actor)
             return curr_passage.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def update_source_passage_by_id(
-        self, passage_id: str, passage: PydanticPassage, actor: PydanticUser, **kwargs
-    ) -> Optional[PydanticPassage]:
-        """Update a source passage."""
-        if not passage_id:
-            raise ValueError("Passage ID must be provided.")
-
-        with db_registry.session() as session:
-            try:
-                curr_passage = SourcePassage.read(
-                    db_session=session,
-                    identifier=passage_id,
-                    actor=actor,
-                )
-            except NoResultFound:
-                raise ValueError(f"Source passage with id {passage_id} does not exist.")
-
-            # Update the database record with values from the provided record
-            update_data = passage.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
-            for key, value in update_data.items():
-                setattr(curr_passage, key, value)
-
-            # Commit changes
-            curr_passage.update(session, actor=actor)
-            return curr_passage.to_pydantic()
-
     @enforce_types
     @trace_method
     async def update_source_passage_by_id_async(
@@ -794,21 +599,6 @@ class PassageManager:
             await curr_passage.update_async(session, actor=actor)
             return curr_passage.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def delete_agent_passage_by_id(self, passage_id: str, actor: PydanticUser) -> bool:
-        """Delete an agent passage."""
-        if not passage_id:
-            raise ValueError("Passage ID must be provided.")
-
-        with db_registry.session() as session:
-            try:
-                passage = ArchivalPassage.read(db_session=session, identifier=passage_id, actor=actor)
-                passage.hard_delete(session, actor=actor)
-                return True
-            except NoResultFound:
-                raise NoResultFound(f"Agent passage with id {passage_id} not found.")
-
     @enforce_types
     @trace_method
     async def delete_agent_passage_by_id_async(self, passage_id: str, actor: PydanticUser, strict_mode: bool = False) -> bool:
@@ -842,21 +632,6 @@ class PassageManager:
             except NoResultFound:
                 raise NoResultFound(f"Agent passage with id {passage_id} not found.")
 
-    @enforce_types
-    @trace_method
-    def delete_source_passage_by_id(self, passage_id: str, actor: PydanticUser) -> bool:
-        """Delete a source passage."""
-        if not passage_id:
-            raise ValueError("Passage ID must be provided.")
-
-        with db_registry.session() as session:
-            try:
-                passage = SourcePassage.read(db_session=session, identifier=passage_id, actor=actor)
-                passage.hard_delete(session, actor=actor)
-                return True
-            except NoResultFound:
-                raise NoResultFound(f"Source passage with id {passage_id} not found.")
-
     @enforce_types
     @trace_method
     async def delete_source_passage_by_id_async(self, passage_id: str, actor: PydanticUser) -> bool:
@@ -872,80 +647,6 @@ class PassageManager:
             except NoResultFound:
                 raise NoResultFound(f"Source passage with id {passage_id} not found.")
 
-    # DEPRECATED - Use specific methods above
-    @enforce_types
-    @trace_method
-    def update_passage_by_id(self, passage_id: str, passage: PydanticPassage, actor: PydanticUser, **kwargs) -> Optional[PydanticPassage]:
-        """DEPRECATED: Use update_agent_passage_by_id() or update_source_passage_by_id() instead."""
-        import warnings
-
-        warnings.warn(
-            "update_passage_by_id is deprecated. Use update_agent_passage_by_id() or update_source_passage_by_id() instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        if not passage_id:
-            raise ValueError("Passage ID must be provided.")
-
-        with db_registry.session() as session:
-            # Try source passages first
-            try:
-                curr_passage = SourcePassage.read(
-                    db_session=session,
-                    identifier=passage_id,
-                    actor=actor,
-                )
-            except NoResultFound:
-                # Try agent passages
-                try:
-                    curr_passage = ArchivalPassage.read(
-                        db_session=session,
-                        identifier=passage_id,
-                        actor=actor,
-                    )
-                except NoResultFound:
-                    raise ValueError(f"Passage with id {passage_id} does not exist.")
-
-            # Update the database record with values from the provided record
-            update_data = passage.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
-            for key, value in update_data.items():
-                setattr(curr_passage, key, value)
-
-            # Commit changes
-            curr_passage.update(session, actor=actor)
-            return curr_passage.to_pydantic()
-
-    @enforce_types
-    @trace_method
-    def delete_passage_by_id(self, passage_id: str, actor: PydanticUser) -> bool:
-        """DEPRECATED: Use delete_agent_passage_by_id() or delete_source_passage_by_id() instead."""
-        import warnings
-
-        warnings.warn(
-            "delete_passage_by_id is deprecated. Use delete_agent_passage_by_id() or delete_source_passage_by_id() instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        if not passage_id:
-            raise ValueError("Passage ID must be provided.")
-
-        with db_registry.session() as session:
-            # Try source passages first
-            try:
-                passage = SourcePassage.read(db_session=session, identifier=passage_id, actor=actor)
-                passage.hard_delete(session, actor=actor)
-                return True
-            except NoResultFound:
-                # Try archival passages
-                try:
-                    passage = ArchivalPassage.read(db_session=session, identifier=passage_id, actor=actor)
-                    passage.hard_delete(session, actor=actor)
-                    return True
-                except NoResultFound:
-                    raise NoResultFound(f"Passage with id {passage_id} not found.")
-
     @enforce_types
     @trace_method
     async def delete_passage_by_id_async(self, passage_id: str, actor: PydanticUser) -> bool:
@@ -1077,36 +778,6 @@ class PassageManager:
             self.delete_passage_by_id(passage_id=passage.id, actor=actor)
         return True
 
-    @enforce_types
-    @trace_method
-    def agent_passage_size(
-        self,
-        actor: PydanticUser,
-        agent_id: Optional[str] = None,
-    ) -> int:
-        """Get the total count of agent passages with optional filters.
-
-        Args:
-            actor: The user requesting the count
-            agent_id: The agent ID of the messages
-        """
-        with db_registry.session() as session:
-            if agent_id:
-                # Count passages through the archives relationship
-                return (
-                    session.query(ArchivalPassage)
-                    .join(ArchivesAgents, ArchivalPassage.archive_id == ArchivesAgents.archive_id)
-                    .filter(
-                        ArchivesAgents.agent_id == agent_id,
-                        ArchivalPassage.organization_id == actor.organization_id,
-                        ArchivalPassage.is_deleted == False,
-                    )
-                    .count()
-                )
-            else:
-                # Count all archival passages in the organization
-                return ArchivalPassage.size(db_session=session, actor=actor)
-
     # DEPRECATED - Use agent_passage_size() instead since this only counted agent passages anyway
     @enforce_types
     @trace_method
@@ -1152,22 +823,6 @@ class PassageManager:
                 # Count all archival passages in the organization
                 return await ArchivalPassage.size_async(db_session=session, actor=actor)
 
-    @enforce_types
-    @trace_method
-    def source_passage_size(
-        self,
-        actor: PydanticUser,
-        source_id: Optional[str] = None,
-    ) -> int:
-        """Get the total count of source passages with optional filters.
-
-        Args:
-            actor: The user requesting the count
-            source_id: The source ID of the passages
-        """
-        with db_registry.session() as session:
-            return SourcePassage.size(db_session=session, actor=actor, source_id=source_id)
-
     @enforce_types
     @trace_method
     async def source_passage_size_async(

letta/services/provider_manager.py

@@ -10,27 +10,6 @@ from letta.utils import enforce_types
 
 
 class ProviderManager:
-    @enforce_types
-    @trace_method
-    def create_provider(self, request: ProviderCreate, actor: PydanticUser) -> PydanticProvider:
-        """Create a new provider if it doesn't already exist."""
-        with db_registry.session() as session:
-            provider_create_args = {**request.model_dump(), "provider_category": ProviderCategory.byok}
-            provider = PydanticProvider(**provider_create_args)
-
-            if provider.name == provider.provider_type.value:
-                raise ValueError("Provider name must be unique and different from provider type")
-
-            # Assign the organization id based on the actor
-            provider.organization_id = actor.organization_id
-
-            # Lazily create the provider id prior to persistence
-            provider.resolve_identifier()
-
-            new_provider = ProviderModel(**provider.model_dump(to_orm=True, exclude_unset=True))
-            new_provider.create(session, actor=actor)
-            return new_provider.to_pydantic()
-
     @enforce_types
     @trace_method
     async def create_provider_async(self, request: ProviderCreate, actor: PydanticUser) -> PydanticProvider:
@@ -52,23 +31,6 @@ class ProviderManager:
             await new_provider.create_async(session, actor=actor)
             return new_provider.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def update_provider(self, provider_id: str, provider_update: ProviderUpdate, actor: PydanticUser) -> PydanticProvider:
-        """Update provider details."""
-        with db_registry.session() as session:
-            # Retrieve the existing provider by ID
-            existing_provider = ProviderModel.read(db_session=session, identifier=provider_id, actor=actor, check_is_deleted=True)
-
-            # Update only the fields that are provided in ProviderUpdate
-            update_data = provider_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
-            for key, value in update_data.items():
-                setattr(existing_provider, key, value)
-
-            # Commit the updated provider
-            existing_provider.update(session, actor=actor)
-            return existing_provider.to_pydantic()
-
     @enforce_types
     @trace_method
     async def update_provider_async(self, provider_id: str, provider_update: ProviderUpdate, actor: PydanticUser) -> PydanticProvider:
@@ -88,21 +50,6 @@ class ProviderManager:
             await existing_provider.update_async(session, actor=actor)
             return existing_provider.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def delete_provider_by_id(self, provider_id: str, actor: PydanticUser):
-        """Delete a provider."""
-        with db_registry.session() as session:
-            # Clear api key field
-            existing_provider = ProviderModel.read(db_session=session, identifier=provider_id, actor=actor, check_is_deleted=True)
-            existing_provider.api_key = None
-            existing_provider.update(session, actor=actor)
-
-            # Soft delete in provider table
-            existing_provider.delete(session, actor=actor)
-
-            session.commit()
-
     @enforce_types
     @trace_method
     async def delete_provider_by_id_async(self, provider_id: str, actor: PydanticUser):
@@ -120,33 +67,6 @@ class ProviderManager:
 
             await session.commit()
 
-    @enforce_types
-    @trace_method
-    def list_providers(
-        self,
-        actor: PydanticUser,
-        name: Optional[str] = None,
-        provider_type: Optional[ProviderType] = None,
-        after: Optional[str] = None,
-        limit: Optional[int] = 50,
-    ) -> List[PydanticProvider]:
-        """List all providers with optional pagination."""
-        filter_kwargs = {}
-        if name:
-            filter_kwargs["name"] = name
-        if provider_type:
-            filter_kwargs["provider_type"] = provider_type
-        with db_registry.session() as session:
-            providers = ProviderModel.list(
-                db_session=session,
-                after=after,
-                limit=limit,
-                actor=actor,
-                check_is_deleted=True,
-                **filter_kwargs,
-            )
-            return [provider.to_pydantic() for provider in providers]
-
     @enforce_types
     @trace_method
     async def list_providers_async(