py-aidol 0.4.0__tar.gz → 0.5.1__tar.gz

{py_aidol-0.4.0 → py_aidol-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-aidol
-Version: 0.4.0
+Version: 0.5.1
 Summary: Create and chat with your own AI idol group
 License: Apache-2.0
 Keywords: kpop,idol,aidol,ai-companion,chatbot,image-generation
@@ -16,6 +16,9 @@ Requires-Dist: aioia-core (>=2.2.0,<3.0.0)
 Requires-Dist: fastapi (>=0.115.12,<0.116.0)
 Requires-Dist: google-genai (>=1.60.0,<2.0.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: langchain-core (>=0.3.0)
+Requires-Dist: langchain-openai (>=0.3.0)
+Requires-Dist: litellm (>=1.60.0)
 Requires-Dist: openai (>=1.0.0)
 Requires-Dist: pillow (>=10.0.0,<11.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)

{py_aidol-0.4.0 → py_aidol-0.5.1}/aidol/api/__init__.py

@@ -3,11 +3,14 @@ AIdol API routers
 """
 
 from aidol.api.aidol import AIdolRouter, create_aidol_router
+from aidol.api.chatroom import ChatroomRouter, create_chatroom_router
 from aidol.api.companion import CompanionRouter, create_companion_router
 
 __all__ = [
     "AIdolRouter",
+    "ChatroomRouter",
     "CompanionRouter",
     "create_aidol_router",
+    "create_chatroom_router",
     "create_companion_router",
 ]

py_aidol-0.5.1/aidol/api/chatroom.py

@@ -0,0 +1,325 @@
+"""
+Chatroom API router
+
+Implements BaseCrudRouter pattern for consistency with aioia-core patterns.
+"""
+
+from aioia_core.auth import UserInfoProvider
+from aioia_core.errors import ErrorResponse
+from aioia_core.fastapi import BaseCrudRouter
+from aioia_core.settings import JWTSettings, OpenAIAPISettings
+from fastapi import APIRouter, Depends, HTTPException, status
+from humps import camelize
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
+from pydantic import BaseModel, ConfigDict, Field
+from sqlalchemy.orm import Session, sessionmaker
+
+from aidol.context import MessageContextBuilder
+from aidol.protocols import (
+    ChatroomRepositoryFactoryProtocol,
+    ChatroomRepositoryProtocol,
+    CompanionRepositoryFactoryProtocol,
+)
+from aidol.providers.llm import OpenAILLMProvider
+from aidol.schemas import (
+    Chatroom,
+    ChatroomCreate,
+    ChatroomUpdate,
+    CompanionMessageCreate,
+    Message,
+    MessageCreate,
+    ModelSettings,
+    Persona,
+    SenderType,
+)
+from aidol.services import ResponseGenerationService
+from aidol.settings import Settings
+
+# Maximum number of messages to fetch for conversation history
+DEFAULT_HISTORY_LIMIT = 200
+
+
+class ChatroomSingleItemResponse(BaseModel):
+    """Single item response for chatroom."""
+
+    data: Chatroom
+
+
+class GenerateResponse(BaseModel):
+    """Response schema for generate_response endpoint."""
+
+    model_config = ConfigDict(populate_by_name=True, alias_generator=camelize)
+
+    message_id: str = Field(..., description="Message ID")
+    content: str = Field(..., description="AI response content")
+
+
+def _to_langchain_messages(messages: list[Message]) -> list[BaseMessage]:
+    """
+    Convert Message schemas to LangChain BaseMessage format.
+
+    Args:
+        messages: List of Message from repository.
+
+    Returns:
+        List of LangChain BaseMessage (HumanMessage or AIMessage).
+    """
+    result: list[BaseMessage] = []
+    for msg in messages:
+        if msg.sender_type == SenderType.USER:
+            result.append(HumanMessage(content=msg.content))
+        else:
+            result.append(AIMessage(content=msg.content))
+    return result
+
+
+class ChatroomRouter(
+    BaseCrudRouter[Chatroom, ChatroomCreate, ChatroomUpdate, ChatroomRepositoryProtocol]
+):
+    """
+    Chatroom router with custom message endpoints.
+
+    Extends BaseCrudRouter for consistent architecture pattern.
+    Disables default CRUD endpoints and provides custom message endpoints.
+    """
+
+    def __init__(
+        self,
+        model_settings: Settings,
+        openai_settings: OpenAIAPISettings,
+        companion_repository_factory: CompanionRepositoryFactoryProtocol,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.model_settings = model_settings
+        self.openai_settings = openai_settings
+        self.companion_repository_factory = companion_repository_factory
+
+    def _register_routes(self) -> None:
+        """Register routes (fancall pattern: public CRUD + message endpoints)"""
+        # Chatroom CRUD (public, no auth)
+        self._register_public_create_route()
+        self._register_public_get_route()
+
+        # Message endpoints (public)
+        self._register_get_messages_route()
+        self._register_send_message_route()
+        self._register_generate_response_route()
+
+    def _register_public_create_route(self) -> None:
+        """POST /{resource_name} - Create a chatroom (public, fancall pattern)"""
+
+        @self.router.post(
+            f"/{self.resource_name}",
+            response_model=ChatroomSingleItemResponse,
+            status_code=status.HTTP_201_CREATED,
+            summary="Create chatroom",
+            description="Create a new chatroom (public endpoint)",
+        )
+        async def create_chatroom(
+            request: ChatroomCreate,
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Create a new chatroom."""
+            created = repository.create(request)
+            return ChatroomSingleItemResponse(data=created)
+
+    def _register_public_get_route(self) -> None:
+        """GET /{resource_name}/{id} - Get a chatroom (public, fancall pattern)"""
+
+        @self.router.get(
+            f"/{self.resource_name}/{{item_id}}",
+            response_model=ChatroomSingleItemResponse,
+            status_code=status.HTTP_200_OK,
+            summary="Get chatroom",
+            description="Get chatroom by ID (public endpoint)",
+            responses={
+                404: {"model": ErrorResponse, "description": "Chatroom not found"},
+            },
+        )
+        async def get_chatroom(
+            item_id: str,
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Get chatroom by ID."""
+            chatroom = self._get_item_or_404(repository, item_id)
+            return ChatroomSingleItemResponse(data=chatroom)
+
+    def _register_get_messages_route(self) -> None:
+        """GET /{resource_name}/{id}/messages - Get messages from a chatroom"""
+
+        @self.router.get(
+            f"/{self.resource_name}/{{item_id}}/messages",
+            response_model=list[Message],
+            status_code=status.HTTP_200_OK,
+            summary="Get messages",
+            description="Get messages from a chatroom",
+        )
+        async def get_messages(
+            item_id: str,
+            limit: int = 100,
+            offset: int = 0,
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Get messages from a chatroom."""
+            return repository.get_messages_by_chatroom_id(
+                chatroom_id=item_id,
+                limit=limit,
+                offset=offset,
+            )
+
+    def _register_send_message_route(self) -> None:
+        """POST /{resource_name}/{id}/messages - Send a message to a chatroom"""
+
+        @self.router.post(
+            f"/{self.resource_name}/{{item_id}}/messages",
+            response_model=Message,
+            status_code=status.HTTP_201_CREATED,
+            summary="Send message",
+            description="Send a message to a chatroom",
+        )
+        async def send_message(
+            item_id: str,
+            request: MessageCreate,
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Send a message to a chatroom."""
+            # Verify chatroom exists
+            self._get_item_or_404(repository, item_id)
+
+            # Enforce sender_type as USER to prevent spoofing
+            request.sender_type = SenderType.USER
+
+            # Pass MessageCreate directly (aioia-core pattern)
+            return repository.add_message_to_chatroom(
+                chatroom_id=item_id,
+                message=request,
+            )
+
+    def _register_generate_response_route(self) -> None:
+        """POST /{resource_name}/{id}/companions/{companion_id}/response - Generate AI response"""
+
+        @self.router.post(
+            f"/{self.resource_name}/{{item_id}}/companions/{{companion_id}}/response",
+            response_model=GenerateResponse,
+            status_code=status.HTTP_201_CREATED,
+            summary="Generate AI response",
+            description="Generate AI response for a chatroom with a specific companion",
+        )
+        async def generate_response(
+            item_id: str,
+            companion_id: str,
+            db_session: Session = Depends(self.get_db_dep),
+            repository: ChatroomRepositoryProtocol = Depends(self.get_repository_dep),
+        ):
+            """Generate AI response for a chatroom."""
+            # Verify chatroom exists
+            self._get_item_or_404(repository, item_id)
+
+            # Get companion repository with same db session (Buppy pattern)
+            companion_repository = self.companion_repository_factory.create_repository(
+                db_session
+            )
+
+            # Get companion by ID
+            companion = companion_repository.get_by_id(companion_id)
+            if companion is None:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail=f"Companion with id {companion_id} not found",
+                )
+
+            # Get conversation history
+            messages = repository.get_messages_by_chatroom_id(
+                chatroom_id=item_id,
+                limit=DEFAULT_HISTORY_LIMIT,
+                offset=0,
+            )
+
+            # Convert to LangChain BaseMessage format
+            # Reverse: DB returns newest-first, LLM needs chronological order
+            langchain_messages = _to_langchain_messages(list(reversed(messages)))
+
+            # Create persona from companion (KST fixed for MVP)
+            persona = Persona(
+                name=companion.name,
+                system_prompt=companion.system_prompt,
+                timezone_name="Asia/Seoul",
+            )
+            provider = OpenAILLMProvider(settings=self.openai_settings)
+            model_settings = ModelSettings(chat_model=self.model_settings.openai_model)
+
+            # Generate text response using ResponseGenerationService
+            context = (
+                MessageContextBuilder(provider, persona)
+                .with_persona()
+                .with_real_time_context()
+                .with_current_conversation(langchain_messages)
+                .build()
+            )
+            service = ResponseGenerationService(provider, model_settings)
+            response_text = service.generate_response(context)
+
+            # Save companion message (repository handles commit)
+            # Use CompanionMessageCreate (no id) - aioia-core pattern
+            companion_message = repository.add_message_to_chatroom(
+                chatroom_id=item_id,
+                message=CompanionMessageCreate(
+                    content=response_text,
+                    companion_id=companion_id,
+                ),
+            )
+
+            return GenerateResponse(
+                message_id=companion_message.id,
+                content=response_text,
+            )
+
+
+def create_chatroom_router(
+    openai_settings: OpenAIAPISettings,
+    model_settings: Settings,
+    companion_repository_factory: CompanionRepositoryFactoryProtocol,
+    db_session_factory: sessionmaker,
+    repository_factory: ChatroomRepositoryFactoryProtocol,
+    jwt_settings: JWTSettings | None = None,
+    user_info_provider: UserInfoProvider | None = None,
+    resource_name: str = "chatrooms",
+    tags: list[str] | None = None,
+) -> APIRouter:
+    """
+    Create chatroom router with dependency injection.
+
+    Args:
+        openai_settings: OpenAI API settings for LLM provider
+        model_settings: Environment settings for aidol
+        companion_repository_factory: Factory for CompanionRepository.
+            For standalone: Use aidol.factories.CompanionRepositoryFactory.
+            For platform integration: Use CompanionRepositoryFactoryAdapter.
+        db_session_factory: Database session factory
+        repository_factory: Factory implementing ChatroomRepositoryFactoryProtocol.
+            For standalone: Use aidol.factories.ChatroomRepositoryFactory.
+            For platform integration: Use ChatroomRepositoryFactoryAdapter.
+        jwt_settings: Optional JWT settings for authentication
+        user_info_provider: Optional user info provider
+        resource_name: Resource name for routes (default: "chatrooms")
+        tags: Optional OpenAPI tags
+
+    Returns:
+        FastAPI APIRouter instance
+    """
+    router = ChatroomRouter(
+        model_settings=model_settings,
+        openai_settings=openai_settings,
+        companion_repository_factory=companion_repository_factory,
+        model_class=Chatroom,
+        create_schema=ChatroomCreate,
+        update_schema=ChatroomUpdate,
+        db_session_factory=db_session_factory,
+        repository_factory=repository_factory,
+        user_info_provider=user_info_provider,
+        jwt_secret_key=jwt_settings.secret_key if jwt_settings else None,
+        resource_name=resource_name,
+        tags=tags or ["Aidol"],
+    )
+    return router.get_router()

{py_aidol-0.4.0 → py_aidol-0.5.1}/aidol/api/companion.py

@@ -20,17 +20,17 @@ from aidol.protocols import (
     CompanionRepositoryProtocol,
     ImageStorageProtocol,
 )
-from aidol.schemas import (
-    Companion,
-    CompanionCreate,
-    CompanionPublic,
-    CompanionUpdate,
-    Gender,
-)
+from aidol.schemas import Companion, CompanionCreate, CompanionPublic, CompanionUpdate
 from aidol.services.companion_service import to_companion_public
 from aidol.settings import GoogleGenAISettings
 
 
+class CompanionSingleItemResponse(BaseModel):
+    """Single item response for Companion (public)."""
+
+    data: CompanionPublic
+
+
 class CompanionPaginatedResponse(BaseModel):
     """Paginated response for Companion (public)."""
 
@@ -84,45 +84,32 @@ class CompanionRouter(
             response_model=CompanionPaginatedResponse,
             status_code=status.HTTP_200_OK,
             summary="List Companions",
-            description="List all Companions with optional filtering by gender and cast status",
+            description="List all Companions with pagination, sorting, and filtering",
         )
         async def list_companions(
-            gender: Gender | None = Query(None, description="Filter by gender"),
-            is_cast: bool | None = Query(
-                None, alias="isCast", description="Filter by cast status"
+            current: int = Query(1, ge=1, description="Current page number"),
+            page_size: int = Query(
+                10, alias="pageSize", ge=1, le=100, description="Items per page"
+            ),
+            sort_param: str | None = Query(
+                None,
+                alias="sort",
+                description='Sorting criteria in JSON format. Example: [["createdAt","desc"]]',
+            ),
+            filters_param: str | None = Query(
+                None,
+                alias="filters",
+                description="Filter conditions (JSON format)",
             ),
-            aidol_id: str | None = Query(None, description="Filter by AIdol Group ID"),
             repository: CompanionRepositoryProtocol = Depends(self.get_repository_dep),
         ):
-            """List Companions with optional gender and isCast filters."""
-            filter_list: list[dict] = []
-
-            # Add filters only if provided
-            if gender is not None:
-                filter_list.append(
-                    {"field": "gender", "operator": "eq", "value": gender.value}
-                )
-
-            # Filter by aidol_id if provided
-            if aidol_id is not None:
-                filter_list.append(
-                    {"field": "aidol_id", "operator": "eq", "value": aidol_id}
-                )
-
-            # isCast is derived from aidol_id presence
-            # isCast=true → aidol_id is not null (belongs to a group)
-            # isCast=false → aidol_id is null (not in a group)
-            if is_cast is True:
-                filter_list.append(
-                    {"field": "aidol_id", "operator": "ne", "value": None}
-                )
-            elif is_cast is False:
-                filter_list.append(
-                    {"field": "aidol_id", "operator": "eq", "value": None}
-                )
-
+            """List Companions with pagination, sorting, and filtering."""
+            sort_list, filter_list = self._parse_query_params(sort_param, filters_param)
             items, total = repository.get_all(
-                filters=filter_list if filter_list else None,
+                current=current,
+                page_size=page_size,
+                sort=sort_list,
+                filters=filter_list,
             )
             # Convert to Public schema (exclude system_prompt)
             public_items = [to_companion_public(c) for c in items]
@@ -133,7 +120,7 @@ class CompanionRouter(
 
         @self.router.post(
             f"/{self.resource_name}",
-            response_model=CompanionPublic,
+            response_model=CompanionSingleItemResponse,
             status_code=status.HTTP_201_CREATED,
             summary="Create Companion",
             description="Create a new Companion. Returns the created companion data.",
@@ -149,17 +136,17 @@ class CompanionRouter(
 
             created = repository.create(sanitized_request)
             # Return created companion as public schema
-            return to_companion_public(created)
+            return CompanionSingleItemResponse(data=to_companion_public(created))
 
     def _register_public_get_route(self) -> None:
         """GET /{resource_name}/{id} - Get a Companion (public)"""
 
         @self.router.get(
             f"/{self.resource_name}/{{item_id}}",
-            response_model=CompanionPublic,
+            response_model=CompanionSingleItemResponse,
             status_code=status.HTTP_200_OK,
             summary="Get Companion",
-            description="Get Companion by ID (public endpoint). Returns companion data directly.",
+            description="Get Companion by ID (public endpoint).",
             responses={
                 404: {"model": ErrorResponse, "description": "Companion not found"},
             },
@@ -171,17 +158,17 @@ class CompanionRouter(
             """Get Companion by ID."""
             companion = self._get_item_or_404(repository, item_id)
             # Return companion as public schema
-            return to_companion_public(companion)
+            return CompanionSingleItemResponse(data=to_companion_public(companion))
 
     def _register_public_update_route(self) -> None:
         """PATCH /{resource_name}/{id} - Update Companion (public)"""
 
         @self.router.patch(
             f"/{self.resource_name}/{{item_id}}",
-            response_model=CompanionPublic,
+            response_model=CompanionSingleItemResponse,
             status_code=status.HTTP_200_OK,
             summary="Update Companion",
-            description="Update Companion by ID (public endpoint). Returns updated companion data directly.",
+            description="Update Companion by ID (public endpoint).",
             responses={
                 404: {"model": ErrorResponse, "description": "Companion not found"},
             },
@@ -206,14 +193,14 @@ class CompanionRouter(
                 )
 
             # Return updated companion as public schema
-            return to_companion_public(updated)
+            return CompanionSingleItemResponse(data=to_companion_public(updated))
 
     def _register_public_delete_route(self) -> None:
         """DELETE /{resource_name}/{id} - Remove Companion from Group (public)"""
 
         @self.router.delete(
             f"/{self.resource_name}/{{item_id}}",
-            response_model=CompanionPublic,
+            response_model=CompanionSingleItemResponse,
             status_code=status.HTTP_200_OK,
             summary="Remove Companion from Group",
             description="Remove Companion from AIdol group (unassign aidol_id). Does not delete the record.",
@@ -241,7 +228,7 @@ class CompanionRouter(
                 )
 
             # Return updated companion as public schema
-            return to_companion_public(updated)
+            return CompanionSingleItemResponse(data=to_companion_public(updated))
 
 
 def create_companion_router(

py_aidol-0.5.1/aidol/context/__init__.py

@@ -0,0 +1,26 @@
+"""Context engineering for AIdol.
+
+This module provides context composition utilities for LLM calls.
+Integrators can extend these base implementations for platform-specific features.
+
+Components:
+- MessageContextBuilder: Builder pattern for assembling LLM context
+"""
+
+from aidol.context.builder import (
+    MessageContextBuilder,
+    deduplicate_consecutive_same_role_messages,
+    ensure_first_user_message,
+    format_datetime_korean,
+    format_utc_offset,
+    verify_system_messages_at_front,
+)
+
+__all__ = [
+    "MessageContextBuilder",
+    "deduplicate_consecutive_same_role_messages",
+    "ensure_first_user_message",
+    "format_datetime_korean",
+    "format_utc_offset",
+    "verify_system_messages_at_front",
+]