Merge branch 'dev'

Author: elian118

docker-compose.yml

@@ -45,7 +45,7 @@ services:
       WEB_HOST: ${WEB_HOST}
       WEB_PORT: ${WEB_PORT}
       # LLM Settings
-      LLM_MODEL_NAME: "${LLM_MODEL_NAME:-gemini-2.5-flash-lite}"
+      LLM_MODEL_NAME: "${LLM_MODEL_NAME:-gpt-4o-mini}"
 
     networks:
       - platform-net

src/configs/llm.py

@@ -18,7 +18,7 @@ class ChatMessage(BaseModel):
 
 
 class ChatCompletionRequest(BaseModel):
-    model: str = "gpt-4"
+    model: str = "gpt-4o-mini"
     messages: List[ChatMessage]
     temperature: float = 0.7
     max_tokens: Optional[int] = None

src/configs/llm_adapter.py

@@ -1,4 +1,5 @@
 import json
+import asyncio
 from typing import Any, List, Optional
 
 import httpx
@@ -34,6 +35,8 @@ class NarrativeChatModel(BaseChatModel):
     )
     client: httpx.AsyncClient
     temperature: float = 0.7
+    llm_retry_attempts: int = 3
+    llm_retry_base_delay: float = 0.8
 
     @property
     def _llm_type(self) -> str:
@@ -87,11 +90,32 @@ async def _agenerate(
             tool_choice=kwargs.get("tool_choice"),
         )
 
-        response = await self.client.post(
-            f"{self.base_url}/api/v1/chat/completions",
-            json=request_body.model_dump(exclude_none=True),
-        )
-        response.raise_for_status()
+        response: httpx.Response | None = None
+        last_error: Exception | None = None
+        for attempt in range(1, self.llm_retry_attempts + 1):
+            try:
+                response = await self.client.post(
+                    f"{self.base_url}/api/v1/chat/completions",
+                    json=request_body.model_dump(exclude_none=True),
+                )
+                if response.status_code >= 500:
+                    raise httpx.HTTPStatusError(
+                        f"llm gateway {response.status_code}",
+                        request=response.request,
+                        response=response,
+                    )
+                response.raise_for_status()
+                break
+            except (httpx.RequestError, httpx.HTTPStatusError) as e:
+                last_error = e
+                if attempt >= self.llm_retry_attempts:
+                    raise
+                await asyncio.sleep(self.llm_retry_base_delay * (2 ** (attempt - 1)))
+
+        if response is None:
+            if last_error:
+                raise last_error
+            raise RuntimeError("LLM request failed without response")
 
         chat_response = ChatCompletionResponse(**response.json())
 

src/configs/llm_manager.py

@@ -12,7 +12,7 @@ class LLMManager:
     _instances = {}
 
     @classmethod
-    def get_instance(cls, provider="gemini", temperature=0.0):
+    def get_instance(cls, provider="gateway", temperature=0.0):
         provider = provider.lower()
         instance_key = f"{provider}_{temperature}"  # 고유 키
 

src/domains/play/dtos/play_dtos.py

@@ -104,6 +104,7 @@ class PlaySceneRequest(BaseModel):
     session_id: str
     scenario_id: str
     locale_id: int
+    sequence_type: Optional[str] = None
     entities: List[EntityUnit]
     relations: List[UpdateRelation]
     story: str

src/domains/play/utils/nodes.py

@@ -12,6 +12,7 @@
 from domains.info.world_service import WorldService
 from domains.play.dtos.play_dtos import (
     EntityType,
+    PhaseType,
     PlaySessionState,
     SceneAnalysis,
 )
@@ -20,6 +21,29 @@
 from utils.proxy_request import proxy_request
 
 
+def _phase_from_sequence_type(raw: str | None) -> PhaseType | None:
+    if not raw:
+        return None
+    norm = str(raw).strip().upper()
+    if not norm:
+        return None
+    if any(k in norm for k in ["COMBAT", "BATTLE", "BOSS", "교전", "결전"]):
+        return PhaseType.COMBAT
+    if any(k in norm for k in ["DIALOG", "DIALOGUE", "대화"]):
+        return PhaseType.DIALOGUE
+    if any(k in norm for k in ["NEGO", "NEGOTIATION", "협상", "흥정"]):
+        return PhaseType.NEGO
+    if any(k in norm for k in ["REST", "휴식"]):
+        return PhaseType.REST
+    if any(k in norm for k in ["RECOVERY", "HEAL", "회복"]):
+        return PhaseType.RECOVERY
+    if any(k in norm for k in ["INFILTRATION", "STEALTH", "잠입"]):
+        return PhaseType.EXPLORATION
+    if any(k in norm for k in ["EXPLORATION", "EXPLORE", "탐색"]):
+        return PhaseType.EXPLORATION
+    return None
+
+
 async def get_player_state_from_proxy(player_id: str) -> FullPlayerState:
     """
     플레이어 상태를 GDB로 관리하는 외부 마이크로서비스를 호출해서 정보를 조회합니다.
@@ -94,6 +118,22 @@ async def analyze_scene_node(state: PlaySessionState) -> Dict[str, Any]:
     """
     LLM을 사용하여 스토리를 분석하고 페이즈 유형을 결정합니다.
     """
+    forced_phase = _phase_from_sequence_type(state.request.sequence_type)
+    if forced_phase is not None:
+        analysis = SceneAnalysis(
+            phase_type=forced_phase,
+            reason=f"sequence_type hint applied: {state.request.sequence_type}",
+            confidence=1.0,
+        )
+        logs = state.logs[:]
+        logs.append(f"분석된 플레이 유형: {analysis.phase_type}")
+        logs.append(f"사유: {analysis.reason}")
+        logs.append(f"분석 확신도: {analysis.confidence}")
+        rule(f"분석된 플레이 유형: {analysis.phase_type}")
+        rule(f"분석 근거: {analysis.reason}")
+        rule(f"분석 확신도: {analysis.confidence}")
+        return {"analysis": analysis, "logs": logs}
+
     current_dir = os.path.dirname(os.path.abspath(__file__))
     prompt_path = os.path.join(current_dir, "..", "prompts", "instruction.md")
 

src/domains/play/utils/phase_nodes/combat_node.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from domains.gm.gm_service import GmService
 from domains.info.enemy_service import EnemyService
@@ -9,9 +9,84 @@
     PlaySessionState,
     RelationType,
 )
+from domains.play.dtos.player_dtos import ItemBase
 from utils.logger import rule
 
 
+def _try_parse_int(value: Optional[str]) -> Optional[int]:
+    if value is None:
+        return None
+    raw = str(value).strip()
+    if not raw or not raw.isdigit():
+        return None
+    return int(raw)
+
+
+def _is_combat_item_type(item_type: Optional[str]) -> bool:
+    if not item_type:
+        return False
+    normalized = str(item_type).strip().lower()
+    return normalized in {"무기", "방어구", "equipment", "weapon", "armor"}
+
+
+def _extract_effect_value(meta: Dict[str, Any]) -> int:
+    if not isinstance(meta, dict):
+        return 0
+    for key in (
+        "effect_value",
+        "attack_bonus",
+        "defense_bonus",
+        "attack",
+        "defense",
+        "power",
+    ):
+        value = meta.get(key)
+        if value is None:
+            continue
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            continue
+    return 0
+
+
+async def _calculate_player_combat_item_effect(
+    player_items: List[ItemBase], item_service: ItemService, logs: List[str]
+) -> int:
+    numeric_item_ids: List[int] = []
+    for item in player_items:
+        parsed = _try_parse_int(item.item_id)
+        if parsed is not None:
+            numeric_item_ids.append(parsed)
+
+    effect_sum = 0
+    resolved_numeric_ids: set[str] = set()
+    if numeric_item_ids:
+        items, _ = await item_service.get_items(
+            item_ids=list(set(numeric_item_ids)), skip=0, limit=100
+        )
+        for db_item in items:
+            if _is_combat_item_type(db_item.get("type")):
+                effect_sum += int(db_item.get("effect_value") or 0)
+            db_item_id = db_item.get("item_id")
+            if db_item_id is not None:
+                resolved_numeric_ids.add(str(db_item_id))
+
+    # scenario_item_id(문자열) 기반 인벤토리도 처리되도록 로컬 메타를 fallback으로 사용.
+    for item in player_items:
+        if item.item_id in resolved_numeric_ids:
+            continue
+        if not _is_combat_item_type(item.item_type):
+            continue
+        effect_sum += _extract_effect_value(item.meta)
+
+    if effect_sum > 0:
+        logs.append(f"전투 보정치(아이템): {effect_sum}")
+        rule(f"전투 보정치(아이템): {effect_sum}")
+
+    return effect_sum
+
+
 async def combat_node(state: PlaySessionState) -> Dict[str, Any]:
     """
     전투 페이즈 로직을 처리합니다.
@@ -30,6 +105,7 @@ async def combat_node(state: PlaySessionState) -> Dict[str, Any]:
 
     if not player_id or not player_state:
         logs.append("전투 페이즈: 플레이어 정보를 찾을 수 없습니다.")
+        rule("전투 페이즈: 플레이어 정보를 찾을 수 없습니다.")
         return {
             "diffs": state.diffs,
             "relations": state.relations,
@@ -39,7 +115,7 @@ async def combat_node(state: PlaySessionState) -> Dict[str, Any]:
 
     # 적 상세정보 조회
     combat_enemies_info = []
-    enemy_state_ids = {
+    hostile_enemy_state_ids = {
         (
             rel.effect_entity_id
             if rel.cause_entity_id == player_id
@@ -50,9 +126,22 @@ async def combat_node(state: PlaySessionState) -> Dict[str, Any]:
         and (rel.cause_entity_id == player_id or rel.effect_entity_id == player_id)
     }
 
+    # Fallback: relation 정보가 비어도 요청에 포함된 enemy 엔티티를 전투 대상으로 사용.
+    enemy_state_ids = (
+        hostile_enemy_state_ids
+        if hostile_enemy_state_ids
+        else {e.state_entity_id for e in enemies}
+    )
+    if not hostile_enemy_state_ids and enemies:
+        no_enemies_log = (
+            "적대 관계 정보가 없어 요청 enemy 목록 전체를 전투 대상으로 사용합니다."
+        )
+        logs.append(no_enemies_log)
+        rule(no_enemies_log)
+
     enemy_id_map = {
         e.state_entity_id: e.entity_id
-        for e in entities_in_request
+        for e in enemies
         if e.state_entity_id in enemy_state_ids and e.entity_id is not None
     }
 
@@ -64,16 +153,26 @@ async def combat_node(state: PlaySessionState) -> Dict[str, Any]:
 
     for state_id in enemy_state_ids:
         rdb_id = enemy_id_map.get(state_id)
-        if rdb_id:
+        base_difficulty = None
+        if rdb_id is not None:
             enemy_data = enemy_details_map.get(rdb_id)
-            if enemy_data and "base_difficulty" in enemy_data:
-                combat_enemies_info.append(
-                    {
-                        "rdb_id": rdb_id,
-                        "state_id": state_id,
-                        "base_difficulty": enemy_data["base_difficulty"],
-                    }
-                )
+            if enemy_data and enemy_data.get("base_difficulty") is not None:
+                base_difficulty = int(enemy_data["base_difficulty"])
+
+        if base_difficulty is None:
+            # 상세 조회 실패 시에도 전투 처리를 중단하지 않기 위한 기본 난이도
+            base_difficulty = 6
+            no_enemy_detail_log = f"적 상세정보 누락(state_id={state_id}, rdb_id={rdb_id})으로 기본 난이도 6을 사용합니다."
+            logs.append(no_enemy_detail_log)
+            rule(no_enemy_detail_log)
+
+        combat_enemies_info.append(
+            {
+                "rdb_id": rdb_id,
+                "state_id": state_id,
+                "base_difficulty": base_difficulty,
+            }
+        )
 
     # 플레이어 전투력 계산
     combat_logs: List[str] = []
@@ -82,13 +181,9 @@ async def combat_node(state: PlaySessionState) -> Dict[str, Any]:
     rule(dice_result_log)
     combat_logs.append(dice_result_log)
 
-    combat_items_effect = 0
-    item_ids = [int(item.item_id) for item in player_state.player.items]
-    if len(item_ids) > 0:
-        items, _ = await item_service.get_items(item_ids=item_ids, skip=0, limit=100)
-        combat_items_effect = sum(
-            item["effect_value"] for item in items if item["type"] in ("무기", "방어구")
-        )
+    combat_items_effect = await _calculate_player_combat_item_effect(
+        player_state.player.items, item_service, logs
+    )
 
     ability_score = 2  # Hardcoded
     player_combat_power = combat_items_effect + ability_score + dice.total
@@ -125,6 +220,7 @@ async def combat_node(state: PlaySessionState) -> Dict[str, Any]:
             )
             diffs.append(new_diff)
             logs.append(f"전투 승리! 적에게 {power_gap}의 데미지를 입혔습니다.")
+            rule(f"전투 승리! 적에게 {power_gap}의 데미지를 입혔습니다.")
 
         elif power_gap < 0:
             is_success = False
@@ -134,8 +230,10 @@ async def combat_node(state: PlaySessionState) -> Dict[str, Any]:
             )
             diffs.append(new_diff)
             logs.append(f"전투 패배... 플레이어가 {-power_gap}의 데미지를 입었습니다.")
+            rule(f"전투 패배... 플레이어가 {-power_gap}의 데미지를 입었습니다.")
         else:
             logs.append("막상막하의 대결이었습니다!")
+            rule("막상막하의 대결이었습니다!")
 
     return {
         "diffs": diffs,