refactor: separate MCP tools to mcp_tools.py

app.py

@@ -5,19 +5,16 @@ import sys
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
 
 import logging
-import uuid
 
 import gradio as gr
 import spaces
 
 from unpredictable_lord.chat import chat_with_llm_stream
-from unpredictable_lord.game_state import (
-    ADVICE_DESCRIPTIONS,
-    PERSONALITY_DESCRIPTIONS,
-    create_session,
-    execute_turn_logic,
-    get_available_advice,
-    get_session,
+from unpredictable_lord.mcp_tools import (
+    execute_turn,
+    get_game_state,
+    init_game,
+    list_available_advice,
 )
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
@@ -26,133 +23,6 @@ logger = logging.getLogger(__name__)
 logger.info(f"ZeroGPU: {spaces.config.Config.zero_gpu}")
 
 
-def init_game(personality: str = "cautious") -> dict:
-    """
-    Initialize a new game session and return the session information.
-
-    This MCP tool creates a new game session with the specified lord personality.
-    Use the returned session_id for all subsequent game operations.
-
-    Args:
-        personality: The lord's personality type.
-                     Options: "cautious" (risk-averse), "idealist" (emotional idealist),
-                     "populist" (popularity-focused). Defaults to "cautious".
-
-    Returns:
-        dict: Session information including session_id and initial game state.
-    """
-    session_id = str(uuid.uuid4())
-
-    # Validate personality
-    if personality not in PERSONALITY_DESCRIPTIONS:
-        personality = "cautious"
-
-    # Create game session using game_state module
-    state = create_session(session_id, personality)
-
-    logger.info(
-        f"New game session created: {session_id} with personality: {personality}"
-    )
-
-    return {
-        "session_id": session_id,
-        "message": f"New game started! You are now the advisor to a {personality} lord.",
-        "personality_description": PERSONALITY_DESCRIPTIONS[personality],
-        "available_advice": ADVICE_DESCRIPTIONS,
-        "game_state": state.to_dict(),
-    }
-
-
-def get_game_state(session_id: str) -> dict:
-    """
-    Get the current game state for a session.
-
-    This MCP tool retrieves the current state of a game session,
-    including all parameters, turn number, and game status.
-
-    Args:
-        session_id: The session ID returned from init_game.
-
-    Returns:
-        dict: Current game state or error message if session not found.
-    """
-    state = get_session(session_id)
-
-    if state is None:
-        return {
-            "error": "Session not found",
-            "message": f"No game session found with ID: {session_id}. Please call init_game first.",
-        }
-
-    return {
-        "session_id": session_id,
-        "game_state": state.to_dict(),
-        "status_summary": state.get_status_summary(),
-    }
-
-
-def list_available_advice() -> dict:
-    """
-    Get all available advice options that can be given to the lord.
-
-    This MCP tool returns a list of all possible advice types that can be
-    used with execute_turn(). The Lord AI should interpret the user's
-    free-form suggestion and map it to one of these options.
-
-    Returns:
-        dict: Dictionary containing all available advice options with
-              their names, descriptions, and expected effects.
-    """
-    return {
-        "advice_options": get_available_advice(),
-        "usage": "Interpret the user's advice and select the most appropriate option from the list above.",
-    }
-
-
-def execute_turn(session_id: str, advice: str) -> dict:
-    """
-    Execute a turn with the given advice.
-
-    This MCP tool is called by the Lord AI after interpreting the user's suggestion.
-    The lord will decide whether to follow the advice based on personality and trust.
-
-    Args:
-        session_id: The session ID returned from init_game.
-        advice: The advice type to execute. Must be one of:
-                - "increase_tax": Raise taxes (Treasury ↑, Satisfaction ↓)
-                - "decrease_tax": Lower taxes (Treasury ↓, Satisfaction ↑)
-                - "expand_territory": Military expansion (Territory ↑, Treasury ↓, risky)
-                - "improve_diplomacy": Diplomatic efforts (Royal Trust ↑, Treasury ↓)
-                - "public_festival": Hold festival (Satisfaction ↑, Treasury ↓)
-                - "build_infrastructure": Build infrastructure (Population ↑, Treasury ↓)
-                - "do_nothing": Maintain current state
-
-    Returns:
-        dict: Result containing:
-              - adopted: Whether the lord followed the advice
-              - action_taken: The actual action the lord took
-              - parameter_changes: Changes to game parameters
-              - game_over: Whether the game has ended
-              - new_state: Updated game state
-    """
-    state = get_session(session_id)
-
-    if state is None:
-        return {
-            "error": "Session not found",
-            "message": f"No game session found with ID: {session_id}. Please call init_game first.",
-        }
-
-    result = execute_turn_logic(state, advice)
-
-    logger.info(
-        f"Turn executed for session {session_id}: advice={advice}, "
-        f"adopted={result.get('adopted')}, action={result.get('action_taken')}"
-    )
-
-    return result
-
-
 # Gradio UI
 with gr.Blocks(title="Unpredictable Lord") as demo:
     gr.Markdown("# Unpredictable Lord\nLord Advisor AI Simulation")

src/unpredictable_lord/mcp_tools.py

@@ -0,0 +1,147 @@
+"""
+MCP tools for Unpredictable Lord game.
+
+This module contains all MCP tool functions that are exposed
+to external LLM clients via the Gradio MCP server.
+"""
+
+import logging
+import uuid
+
+from unpredictable_lord.game_state import (
+    ADVICE_DESCRIPTIONS,
+    PERSONALITY_DESCRIPTIONS,
+    create_session,
+    execute_turn_logic,
+    get_available_advice,
+    get_session,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def init_game(personality: str = "cautious") -> dict:
+    """
+    Initialize a new game session and return the session information.
+
+    This MCP tool creates a new game session with the specified lord personality.
+    Use the returned session_id for all subsequent game operations.
+
+    Args:
+        personality: The lord's personality type.
+                     Options: "cautious" (risk-averse), "idealist" (emotional idealist),
+                     "populist" (popularity-focused). Defaults to "cautious".
+
+    Returns:
+        dict: Session information including session_id and initial game state.
+    """
+    session_id = str(uuid.uuid4())
+
+    # Validate personality
+    if personality not in PERSONALITY_DESCRIPTIONS:
+        personality = "cautious"
+
+    # Create game session using game_state module
+    state = create_session(session_id, personality)
+
+    logger.info(
+        f"New game session created: {session_id} with personality: {personality}"
+    )
+
+    return {
+        "session_id": session_id,
+        "message": f"New game started! You are now the advisor to a {personality} lord.",
+        "personality_description": PERSONALITY_DESCRIPTIONS[personality],
+        "available_advice": ADVICE_DESCRIPTIONS,
+        "game_state": state.to_dict(),
+    }
+
+
+def get_game_state(session_id: str) -> dict:
+    """
+    Get the current game state for a session.
+
+    This MCP tool retrieves the current state of a game session,
+    including all parameters, turn number, and game status.
+
+    Args:
+        session_id: The session ID returned from init_game.
+
+    Returns:
+        dict: Current game state or error message if session not found.
+    """
+    state = get_session(session_id)
+
+    if state is None:
+        return {
+            "error": "Session not found",
+            "message": f"No game session found with ID: {session_id}. Please call init_game first.",
+        }
+
+    return {
+        "session_id": session_id,
+        "game_state": state.to_dict(),
+        "status_summary": state.get_status_summary(),
+    }
+
+
+def list_available_advice() -> dict:
+    """
+    Get all available advice options that can be given to the lord.
+
+    This MCP tool returns a list of all possible advice types that can be
+    used with execute_turn(). The Lord AI should interpret the user's
+    free-form suggestion and map it to one of these options.
+
+    Returns:
+        dict: Dictionary containing all available advice options with
+              their names, descriptions, and expected effects.
+    """
+    return {
+        "advice_options": get_available_advice(),
+        "usage": "Interpret the user's advice and select the most appropriate option from the list above.",
+    }
+
+
+def execute_turn(session_id: str, advice: str) -> dict:
+    """
+    Execute a turn with the given advice.
+
+    This MCP tool is called by the Lord AI after interpreting the user's suggestion.
+    The lord will decide whether to follow the advice based on personality and trust.
+
+    Args:
+        session_id: The session ID returned from init_game.
+        advice: The advice type to execute. Must be one of:
+                - "increase_tax": Raise taxes (Treasury ↑, Satisfaction ↓)
+                - "decrease_tax": Lower taxes (Treasury ↓, Satisfaction ↑)
+                - "expand_territory": Military expansion (Territory ↑, Treasury ↓, risky)
+                - "improve_diplomacy": Diplomatic efforts (Royal Trust ↑, Treasury ↓)
+                - "public_festival": Hold festival (Satisfaction ↑, Treasury ↓)
+                - "build_infrastructure": Build infrastructure (Population ↑, Treasury ↓)
+                - "do_nothing": Maintain current state
+
+    Returns:
+        dict: Result containing:
+              - adopted: Whether the lord followed the advice
+              - action_taken: The actual action the lord took
+              - parameter_changes: Changes to game parameters
+              - game_over: Whether the game has ended
+              - new_state: Updated game state
+    """
+    state = get_session(session_id)
+
+    if state is None:
+        return {
+            "error": "Session not found",
+            "message": f"No game session found with ID: {session_id}. Please call init_game first.",
+        }
+
+    result = execute_turn_logic(state, advice)
+
+    logger.info(
+        f"Turn executed for session {session_id}: advice={advice}, "
+        f"adopted={result.get('adopted')}, action={result.get('action_taken')}"
+    )
+
+    return result