feat: update game instructions and enhance chat functionality

app.py

@@ -10,7 +10,7 @@ from pathlib import Path
 import gradio as gr
 import spaces
 
-from unpredictable_lord.chat import chat_with_llm_stream, chat_with_mcp_tools
+from unpredictable_lord.chat import chat_with_mcp_tools
 from unpredictable_lord.game_state import PERSONALITY_DESCRIPTIONS
 from unpredictable_lord.mcp_server import (
     execute_turn,
@@ -33,7 +33,12 @@ MCP_GUIDE_PATH = Path(__file__).parent / "docs" / "mcp_guide.md"
 MCP_GUIDE_CONTENT = MCP_GUIDE_PATH.read_text(encoding="utf-8")
 
 # Constants
-NO_GAME_MESSAGE = "_No active game. Click 'Start New Game' to begin._"
+NO_GAME_MESSAGE = """_No active game._
+
+**To start playing:**
+1. Select a Lord Personality above
+2. Click "⚔️ Start New Game"
+"""
 
 
 # Gradio UI
@@ -54,10 +59,11 @@ with gr.Blocks(title="Unpredictable Lord") as demo:
                     with gr.Row():
                         msg = gr.Textbox(
                             label="Your Advice",
-                            placeholder="My Lord, I have a proposal...",
+                            placeholder="Start a new game first...",
                             scale=4,
+                            interactive=False,
                         )
-                        submit_btn = gr.Button("Submit", scale=1)
+                        submit_btn = gr.Button("Submit", scale=1, interactive=False)
 
                 # Right column: Game status panel
                 with gr.Column(scale=1):
@@ -146,6 +152,8 @@ _{personality_desc}_"""
                     state.get("royal_trust", 50),
                     state.get("advisor_trust", 50),
                     [],  # Clear chat history
+                    gr.update(interactive=True, placeholder="My Lord, I have a proposal..."),
+                    gr.update(interactive=True),
                 )
 
             def reset_chat_game():
@@ -160,6 +168,8 @@ _{personality_desc}_"""
                     50,
                     50,
                     [],  # Clear chat history
+                    gr.update(interactive=False, placeholder="Start a new game first..."),
+                    gr.update(interactive=False),
                 )
 
             def refresh_game_state(session_id: str | None):
@@ -227,18 +237,10 @@ _{personality_desc}_"""
                 user_message = history[-1]["content"]
                 history_for_model = history[:-1]
 
-                # Use MCP tools if game session is active
-                if session_id:
-                    async for updated_history in chat_with_mcp_tools(
-                        user_message, history_for_model, session_id, personality
-                    ):
-                        yield updated_history
-                else:
-                    # Fallback to simple chat without tools
-                    for updated_history in chat_with_llm_stream(
-                        user_message, history_for_model
-                    ):
-                        yield updated_history
+                async for updated_history in chat_with_mcp_tools(
+                    user_message, history_for_model, session_id, personality
+                ):
+                    yield updated_history
 
             # Event handlers
             start_game_btn.click(
@@ -254,6 +256,8 @@ _{personality_desc}_"""
                     royal_trust_bar,
                     advisor_trust_bar,
                     chatbot,
+                    msg,
+                    submit_btn,
                 ],
                 show_api=False,
             )
@@ -271,6 +275,8 @@ _{personality_desc}_"""
                     royal_trust_bar,
                     advisor_trust_bar,
                     chatbot,
+                    msg,
+                    submit_btn,
                 ],
                 show_api=False,
             )

src/unpredictable_lord/chat.py

@@ -75,6 +75,14 @@ Available advice options:
 - do_nothing: Maintain current state
 
 After calling execute_turn, summarize the results to your advisor in character.
+
+IMPORTANT: After each action or when starting a conversation:
+1. Explain the current situation and any recent changes
+2. Ask your advisor what they suggest next
+3. Be specific about what challenges or opportunities exist
+
+Example: "The treasury has grown, but whispers of discontent spread among the peasants.
+What counsel do you offer, advisor? Shall we address their grievances or press our advantage?"
 """
 
     return oh.Message.from_role_and_content(
@@ -85,20 +93,6 @@ After calling execute_turn, summarize the results to your advisor in character.
     )
 
 
-def _build_simple_system_message() -> oh.Message:
-    """Build simple system message without tools (for non-game chat)."""
-    system_content = (
-        oh.SystemContent.new()
-        .with_model_identity(
-            "You are a lord of a medieval fantasy kingdom. The user is your advisor. "
-            "Listen to your advisor's advice and act for the development of your territory "
-            "and the maintenance of your authority. Speak in an arrogant tone."
-        )
-        .with_reasoning_effort(oh.ReasoningEffort.LOW)
-    )
-    return oh.Message.from_role_and_content(oh.Role.SYSTEM, system_content)
-
-
 def _convert_history_to_messages(chat_history: list[dict]) -> list[oh.Message]:
     """Convert Gradio chat history to openai-harmony messages.
 
@@ -141,6 +135,7 @@ def _stream_llm_response(messages: list[oh.Message], encoding):
     response_text = ""
     token_count = 0
     parser_error = False
+    all_content = ""  # Capture all content regardless of channel
 
     for token in generate_stream(input_tokens):
         if token is None:
@@ -161,66 +156,30 @@ def _stream_llm_response(messages: list[oh.Message], encoding):
             )
             raise
 
-        # Get content only from final channel
-        if parser.current_channel == "final":
-            delta = parser.last_content_delta
-            if delta:
-                response_text += delta
-                yield response_text, None
+        # Get content from any channel for fallback
+        delta = parser.last_content_delta
+        if delta:
+            all_content += delta
+
+        # Get content only from final channel for display
+        if parser.current_channel == "final" and delta:
+            response_text += delta
+            yield response_text, None
 
     # Finish parsing and return parsed messages
     if not parser_error:
         parser.process_eos()
-    parsed_messages = parser.messages
+        parsed_messages = parser.messages
+    else:
+        # On parser error, return empty list to stop tool calling loop
+        # Use all_content as fallback if response_text is empty
+        if not response_text and all_content:
+            response_text = all_content
+            logger.info(f"Using fallback content (length: {len(all_content)})")
+        parsed_messages = []
     yield response_text, parsed_messages
 
 
-def chat_with_llm_stream(
-    user_message: str,
-    chat_history: list[dict[str, str]],
-):
-    """
-    Chat with LLM (streaming version) - without tool support.
-
-    This is the simple version for when no game session is active.
-
-    Args:
-        user_message: User's message
-        chat_history: Past chat history (list of dictionaries in Gradio format)
-
-    Yields:
-        updated_chat_history: Updated chat history (Gradio format)
-    """
-    try:
-        # Build messages
-        messages = [_build_simple_system_message()]
-        messages.extend(_convert_history_to_messages(chat_history))
-        messages.append(oh.Message.from_role_and_content(oh.Role.USER, user_message))
-
-        encoding = _get_encoding()
-
-        # Build history for UI
-        partial_history = chat_history + [
-            {"role": "user", "content": user_message},
-            {"role": "assistant", "content": ""},
-        ]
-
-        # Stream response
-        for response_text, _ in _stream_llm_response(messages, encoding):
-            partial_history[-1]["content"] = response_text
-            yield partial_history
-
-    except Exception:
-        logger.exception("Error during chat_with_llm_stream")
-        yield chat_history + [
-            {"role": "user", "content": user_message},
-            {
-                "role": "assistant",
-                "content": "[Error occurred while generating response.]",
-            },
-        ]
-
-
 async def chat_with_mcp_tools(
     user_message: str,
     chat_history: list[dict[str, str]],
@@ -308,13 +267,11 @@ async def chat_with_mcp_tools(
             # Log total message count
             logger.debug(f"Total messages after tool execution: {len(messages)}")
 
-            # Reset for next iteration
+            # Clear response for next iteration (will accumulate new response)
             full_response = ""
-            partial_history[-1]["content"] = ""
 
-        # Ensure final response is yielded
-        if partial_history[-1]["content"]:
-            yield partial_history
+        # Ensure final response is yielded (even if empty after tool calls)
+        yield partial_history
 
     except Exception:
         logger.exception("Error during chat_with_mcp_tools")