update

Dockerfile

@@ -0,0 +1,44 @@
+FROM node:18 as client-build
+WORKDIR /app
+COPY client/package*.json ./
+RUN npm install
+COPY client/ ./
+RUN npm run build
+
+FROM python:3.9-slim
+WORKDIR /app
+
+# Create non-root user
+RUN useradd -m -u 1000 user
+
+# Install system dependencies and poetry
+RUN apt-get update && apt-get install -y \
+    netcat-openbsd \
+    && rm -rf /var/lib/apt/lists/* \
+    && pip install poetry
+
+# Copy and install Python dependencies
+COPY server/pyproject.toml server/poetry.lock* ./
+RUN poetry config virtualenvs.create false \
+    && poetry install --no-interaction --no-ansi --only main --no-root
+
+# Copy server code
+COPY server/ ./server/
+
+# Copy client build
+COPY --from=client-build /app/dist ./static
+
+# Environment variables
+ENV API_HOST=0.0.0.0 \
+    API_PORT=7860
+
+# Create cache directory and set permissions
+RUN mkdir -p /app/cache && chown -R user:user /app/cache
+
+# Switch to non-root user
+USER user
+
+EXPOSE 7860
+
+# Start the server
+CMD ["python", "-m", "uvicorn", "server.server:app", "--host", "0.0.0.0", "--port", "7860"]

client/src/App.jsx

@@ -9,7 +9,6 @@ import {
   ListItem,
   ListItemText,
   LinearProgress,
-  ButtonGroup,
 } from "@mui/material";
 import RestartAltIcon from "@mui/icons-material/RestartAlt";
 import axios from "axios";
@@ -19,25 +18,30 @@ function App() {
   const [currentChoices, setCurrentChoices] = useState([]);
   const [isLoading, setIsLoading] = useState(false);
 
-  // Start the story when the component mounts
-  useEffect(() => {
-    handleStoryAction("start");
-  }, []);
-
   const handleStoryAction = async (action, choiceId = null) => {
     setIsLoading(true);
     try {
-      const response = await axios.post("http://localhost:8000/chat", {
+      const response = await axios.post("http://localhost:8000/api/chat", {
         message: action,
         choice_id: choiceId,
       });
 
       if (action === "restart") {
-        setStorySegments([{ text: response.data.story_text, isChoice: false }]);
+        setStorySegments([
+          {
+            text: response.data.story_text,
+            isChoice: false,
+            isDeath: response.data.is_death,
+          },
+        ]);
       } else {
         setStorySegments((prev) => [
           ...prev,
-          { text: response.data.story_text, isChoice: false },
+          {
+            text: response.data.story_text,
+            isChoice: false,
+            isDeath: response.data.is_death,
+          },
         ]);
       }
 
@@ -53,6 +57,11 @@ function App() {
     }
   };
 
+  // Start the story when the component mounts
+  useEffect(() => {
+    handleStoryAction("restart");
+  }, []);
+
   const handleChoice = async (choiceId) => {
     // Add the chosen option to the story
     setStorySegments((prev) => [
@@ -109,12 +118,25 @@ function App() {
                 sx={{
                   p: 2,
                   maxWidth: "80%",
-                  bgcolor: segment.isChoice ? "primary.light" : "grey.100",
-                  color: segment.isChoice ? "white" : "text.primary",
+                  bgcolor: segment.isDeath
+                    ? "error.light"
+                    : segment.isChoice
+                    ? "primary.light"
+                    : "grey.100",
+                  color:
+                    segment.isDeath || segment.isChoice
+                      ? "white"
+                      : "text.primary",
                 }}
               >
                 <ListItemText
-                  primary={segment.isChoice ? "Your Choice" : "Story"}
+                  primary={
+                    segment.isDeath
+                      ? "DEATH"
+                      : segment.isChoice
+                      ? "Your Choice"
+                      : "Story"
+                  }
                   secondary={segment.text}
                   primaryTypographyProps={{
                     variant: "subtitle2",

server/game_logic.py

@@ -0,0 +1,126 @@
+from pydantic import BaseModel, Field
+from typing import List
+from langchain_mistralai.chat_models import ChatMistralAI
+from langchain.output_parsers import PydanticOutputParser, OutputFixingParser
+from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate
+
+# Game constants
+MAX_RADIATION = 10
+
+class GameState:
+    def __init__(self):
+        self.story_beat = 0
+        self.radiation_level = 0
+        
+    def reset(self):
+        self.story_beat = 0
+        self.radiation_level = 0
+
+# Story output structure
+class StorySegment(BaseModel):
+    story_text: str = Field(description="The next segment of the story")
+    choices: List[str] = Field(description="Exactly two possible choices for the player", min_items=2, max_items=2)
+    is_death: bool = Field(description="Whether this segment ends in Sarah's death", default=False)
+    radiation_increase: int = Field(description="How much radiation this segment adds (0-3)", ge=0, le=3, default=1)
+
+class StoryGenerator:
+    def __init__(self, api_key: str):
+        self.parser = PydanticOutputParser(pydantic_object=StorySegment)
+        self.fixing_parser = OutputFixingParser.from_llm(
+            parser=self.parser,
+            llm=ChatMistralAI(
+                mistral_api_key=api_key,
+                model="mistral-small",
+                temperature=0.1
+            )
+        )
+        
+        self.chat_model = ChatMistralAI(
+            mistral_api_key=api_key,
+            model="mistral-small",
+            temperature=0.7
+        )
+        
+        self.prompt = self._create_prompt()
+        
+    def _create_prompt(self) -> ChatPromptTemplate:
+        system_template = """You are narrating an EXTREMELY lethal dystopian story. Your goal is to kill Sarah in creative and brutal ways unless players make PERFECT choices. This is a horror survival game where death is the most common outcome.
+
+IMPORTANT: The first story beat (story_beat = 0) MUST be an introduction that sets up the horror atmosphere but CANNOT kill Sarah. After that, death should be frequent.
+
+RADIATION SYSTEM:
+- Each segment must specify a radiation_increase value (0-3)
+- 0: Safe area or good protection
+- 1: Standard background radiation
+- 2: Dangerous exposure
+- 3: Critical radiation levels
+- Current radiation level: {radiation_level}/10
+- If radiation reaches 10, Sarah dies horribly
+
+Core story elements:
+- Sarah is deeply traumatized by the AI uprising that killed most of humanity
+- She abandoned her sister during the Great Collapse, leaving her to die
+- She's on a suicide mission, but a quick death is not redemption
+- The radiation is EXTREMELY lethal - even minor exposure causes severe damage
+- Most choices should lead to death (except in introduction)
+- The environment actively tries to kill Sarah (raiders, AI, radiation, traps)
+
+Each response MUST contain:
+1. A detailed story segment that puts Sarah in mortal danger (except in introduction), describing:
+   - The horrific environment
+   - The immediate threats to her life
+   - Her deteriorating physical state (based on radiation_level)
+   - Her mental state and previous choices
+
+2. Exactly two VERY CONCISE choices (max 10 words each):
+   Examples of good choices:
+   - "Rush through radiation zone (+3 radiation)" vs "Take long way (+1 radiation)"
+   - "Trust the survivor" vs "Shoot on sight"
+   - "Use the old AI system" vs "Find a manual solution"
+   
+   Each choice must:
+   - Be direct and brief
+   - Clearly show radiation risk when relevant
+   - Feel meaningful
+   - After introduction: both should feel dangerous
+
+{format_instructions}"""
+
+        human_template = """Current story beat: {story_beat}
+Current radiation level: {radiation_level}/10
+Previous choice: {previous_choice}
+
+Generate the next story segment and choices. If this is story_beat 0, create an atmospheric introduction that sets up the horror but doesn't kill Sarah. Otherwise, create a brutal and potentially lethal segment."""
+
+        return ChatPromptTemplate(
+            messages=[
+                SystemMessagePromptTemplate.from_template(system_template),
+                HumanMessagePromptTemplate.from_template(human_template)
+            ],
+            partial_variables={"format_instructions": self.parser.get_format_instructions()}
+        )
+
+    def generate_story_segment(self, game_state: GameState, previous_choice: str = "none") -> StorySegment:
+        # Get the formatted messages
+        messages = self.prompt.format_messages(
+            story_beat=game_state.story_beat,
+            radiation_level=game_state.radiation_level,
+            previous_choice=previous_choice
+        )
+
+        # Get response from the model
+        response = self.chat_model.invoke(messages)
+        
+        # Parse the response with retry mechanism
+        try:
+            parsed_response = self.parser.parse(response.content)
+        except Exception as parsing_error:
+            print(f"First parsing attempt failed, trying to fix output: {str(parsing_error)}")
+            parsed_response = self.fixing_parser.parse(response.content)
+            
+        return parsed_response
+
+    def process_radiation_death(self, segment: StorySegment) -> StorySegment:
+        segment.is_death = True
+        segment.story_text += "\n\nFINAL RADIATION DEATH: Sarah's body finally gives in to the overwhelming radiation. Her cells break down as she collapses, mind filled with regret about her sister. The medical supplies she carried will never reach their destination. Her mission ends here, another victim of the wasteland's invisible killer."
+        return segment 

server/server.py

@@ -1,93 +1,38 @@
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, Field
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
 from typing import List, Optional
 import os
 from dotenv import load_dotenv
-from langchain_mistralai.chat_models import ChatMistralAI
-from langchain.output_parsers import PydanticOutputParser
-from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate
-from langchain.schema import HumanMessage, SystemMessage
+from game_logic import GameState, StoryGenerator, MAX_RADIATION
 
 # Load environment variables
 load_dotenv()
 
+# API configuration
+API_HOST = os.getenv("API_HOST", "0.0.0.0")
+API_PORT = int(os.getenv("API_PORT", "8000"))
+
 app = FastAPI(title="Echoes of Influence")
 
 # Configure CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["http://localhost:5173"],
+    allow_origins=[
+        "http://localhost:5173",  # Vite dev server
+        f"http://localhost:{API_PORT}",  # API port
+        "https://huggingface.co",  # HF main domain
+        "https://*.hf.space",      # HF Spaces domains
+    ],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Game state
-story_beat = 0
-
-# Define the structure we want the LLM to output
-class StorySegment(BaseModel):
-    story_text: str = Field(description="The next segment of the story")
-    choices: List[str] = Field(description="Exactly two possible choices for the player", min_items=2, max_items=2)
-    is_death: bool = Field(description="Whether this segment ends in Sarah's death", default=False)
-
-# Initialize the parser
-parser = PydanticOutputParser(pydantic_object=StorySegment)
-
-# Initialize Mistral Chat Model
-chat_model = ChatMistralAI(
-    mistral_api_key=os.getenv("MISTRAL_API_KEY"),
-    model="mistral-small",
-    temperature=0.7
-)
-
-# Create the system prompt
-system_template = """You are narrating a brutal and unforgiving dystopian story about Sarah, a former engineer on a suicide mission to deliver medical supplies through a deadly radiation-filled wasteland.
-
-Core story elements:
-- Sarah is deeply traumatized by the AI uprising that killed most of humanity
-- She abandoned her sister during the Great Collapse, leaving her to die
-- She's on a suicide mission, but a quick death is not redemption
-- The radiation is lethal and gets worse with each step
-- Wrong choices lead to immediate and graphic deaths
-- The environment is extremely hostile (raiders, malfunctioning AI systems, radiation storms)
-
-Death conditions (implement these strictly):
-- Any direct exposure to high radiation zones is lethal within minutes
-- Trusting the wrong people leads to death
-- Using corrupted AI systems can kill instantly
-- Hesitating too long in dangerous situations is fatal
-- Taking too many risks in succession leads to death
-
-Each response must contain:
-1. A tense story segment that puts Sarah in mortal danger
-2. Exactly two possible choices that represent different approaches:
-   - Each choice must have clear potential consequences
-   - At least one choice should always carry a significant risk of death
-   - Choices should reflect:
-     * Brutal pragmatism vs Emotional responses
-     * Quick but dangerous vs Slow but safer routes
-     * Trust vs Paranoia
-     * Using AI systems vs Manual alternatives
-
-If a choice would realistically lead to death, you MUST end the story with a detailed death scene and set is_death to true.
-
-{format_instructions}"""
-
-human_template = """Current story beat: {story_beat}
-Previous choice: {previous_choice}
-
-Generate the next story segment and choices. Remember: this is a brutal and unforgiving world where wrong choices lead to death."""
-
-# Create the chat prompt
-prompt = ChatPromptTemplate(
-    messages=[
-        SystemMessagePromptTemplate.from_template(system_template),
-        HumanMessagePromptTemplate.from_template(human_template)
-    ],
-    partial_variables={"format_instructions": parser.get_format_instructions()}
-)
+# Initialize game components
+game_state = GameState()
+story_generator = StoryGenerator(api_key=os.getenv("MISTRAL_API_KEY"))
 
 class Choice(BaseModel):
     id: int
@@ -97,61 +42,67 @@ class StoryResponse(BaseModel):
     story_text: str
     choices: List[Choice]
     is_death: bool = False
+    radiation_level: int
 
 class ChatMessage(BaseModel):
     message: str
     choice_id: Optional[int] = None
 
-@app.get("/")
-async def read_root():
-    return {"message": "Welcome to Echoes of Influence"}
-
-@app.post("/chat", response_model=StoryResponse)
+@app.get("/api/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "game_state": {
+            "story_beat": game_state.story_beat,
+            "radiation_level": game_state.radiation_level
+        }
+    }
+
+@app.post("/api/chat", response_model=StoryResponse)
 async def chat_endpoint(chat_message: ChatMessage):
-    global story_beat
-    
     try:
-        # Prepare the context
+        # Handle restart
         if chat_message.message.lower() == "restart":
-            story_beat = 0
+            game_state.reset()
             previous_choice = "none"
-        elif chat_message.choice_id is not None:
-            previous_choice = f"Choice {chat_message.choice_id}"
         else:
-            previous_choice = "none"
+            previous_choice = f"Choice {chat_message.choice_id}" if chat_message.choice_id else "none"
 
-        # Get the formatted messages
-        messages = prompt.format_messages(
-            story_beat=story_beat,
-            previous_choice=previous_choice
-        )
-
-        # Get response from the model
-        response = chat_model.invoke(messages)
+        # Generate story segment
+        story_segment = story_generator.generate_story_segment(game_state, previous_choice)
+        
+        # Update radiation level
+        game_state.radiation_level += story_segment.radiation_increase
         
-        # Parse the response
-        parsed_response = parser.parse(response.content)
+        # Check for radiation death
+        if game_state.radiation_level >= MAX_RADIATION:
+            story_segment = story_generator.process_radiation_death(story_segment)
         
         # Only increment story beat if not dead
-        if not parsed_response.is_death:
-            story_beat += 1
+        if not story_segment.is_death:
+            game_state.story_beat += 1
 
         # Convert to response format
-        choices = [] if parsed_response.is_death else [
+        choices = [] if story_segment.is_death else [
             Choice(id=i, text=choice.strip())
-            for i, choice in enumerate(parsed_response.choices, 1)
+            for i, choice in enumerate(story_segment.choices, 1)
         ]
 
         return StoryResponse(
-            story_text=parsed_response.story_text,
+            story_text=story_segment.story_text,
             choices=choices,
-            is_death=parsed_response.is_death
+            is_death=story_segment.is_death,
+            radiation_level=game_state.radiation_level
         )
 
     except Exception as e:
         print(f"Error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
+# Mount static files (this should be after all API routes)
+app.mount("/", StaticFiles(directory="../client/dist", html=True), name="static")
+
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run("server:app", host="0.0.0.0", port=8000, reload=True) 
+    uvicorn.run("server:app", host=API_HOST, port=API_PORT, reload=True)