update

client/src/components/DebugConsole.jsx

@@ -0,0 +1,54 @@
+import React from "react";
+import { Box, Paper } from "@mui/material";
+
+// Composant pour afficher du JSON avec coloration syntaxique
+const JsonView = ({ data, maxHeight = "500px" }) => (
+  <Box
+    sx={{
+      backgroundColor: "grey.900",
+      p: 2,
+      borderRadius: 1,
+      position: "relative",
+    }}
+  >
+    <Box
+      sx={{
+        maxHeight,
+        overflow: "auto",
+        fontFamily: "monospace",
+        "&::-webkit-scrollbar": {
+          width: "8px",
+          height: "8px",
+        },
+        "&::-webkit-scrollbar-track": {
+          backgroundColor: "grey.800",
+          borderRadius: "4px",
+        },
+        "&::-webkit-scrollbar-thumb": {
+          backgroundColor: "grey.600",
+          borderRadius: "4px",
+          "&:hover": {
+            backgroundColor: "grey.500",
+          },
+        },
+        "& pre": {
+          margin: 0,
+          color: "success.light",
+          fontSize: "0.75rem",
+          whiteSpace: "pre-wrap",
+          wordBreak: "break-word",
+        },
+      }}
+    >
+      <pre>{JSON.stringify(data, null, 2)}</pre>
+    </Box>
+  </Box>
+);
+
+export const DebugConsole = ({ gameState, currentStory }) => {
+  return (
+    <Paper variant="outlined" sx={{ height: "calc(100vh - 100px)" }}>
+      <JsonView data={{ gameState, currentStory }} maxHeight="100%" />
+    </Paper>
+  );
+};

client/src/components/Metric.jsx

@@ -0,0 +1,28 @@
+import React from "react";
+import { Box, Typography } from "@mui/material";
+
+export const Metric = ({ icon, label, value, color = "default" }) => (
+  <Box
+    sx={{
+      display: "flex",
+      alignItems: "center",
+      gap: 1,
+      p: 0.75,
+      borderRadius: 1,
+      backgroundColor: "background.paper",
+      border: 1,
+      borderColor: "divider",
+      minWidth: 180,
+    }}
+  >
+    <Box sx={{ color: `${color}.main` }}>{icon}</Box>
+    <Box>
+      <Typography variant="caption" color="text.secondary">
+        {label}
+      </Typography>
+      <Typography variant="body2" fontWeight="medium" color="text.primary">
+        {value}
+      </Typography>
+    </Box>
+  </Box>
+);

client/src/components/TalkWithSarah.jsx

@@ -1,279 +0,0 @@
-import { useState, useRef, useEffect } from "react";
-import {
-  Box,
-  IconButton,
-  TextField,
-  Dialog,
-  DialogTitle,
-  DialogContent,
-  DialogActions,
-  Button,
-  Tooltip,
-} from "@mui/material";
-import FiberManualRecordIcon from "@mui/icons-material/FiberManualRecord";
-import CheckCircleIcon from "@mui/icons-material/CheckCircle";
-import CancelIcon from "@mui/icons-material/Cancel";
-import { useConversation } from "@11labs/react";
-
-const AGENT_ID = "2MF9st3s1mNFbX01Y106";
-const ELEVEN_LABS_KEY_STORAGE = "eleven_labs_api_key";
-
-export function TalkWithSarah({
-  isNarratorSpeaking,
-  stopNarration,
-  playNarration,
-  onDecisionMade,
-  currentContext,
-}) {
-  const [isRecording, setIsRecording] = useState(false);
-  const [isConversationMode, setIsConversationMode] = useState(false);
-  const [showApiKeyDialog, setShowApiKeyDialog] = useState(false);
-  const [apiKey, setApiKey] = useState(() => {
-    return localStorage.getItem(ELEVEN_LABS_KEY_STORAGE) || "";
-  });
-  const [isApiKeyValid, setIsApiKeyValid] = useState(false);
-  const mediaRecorderRef = useRef(null);
-  const audioChunksRef = useRef([]);
-  const wsRef = useRef(null);
-
-  const conversation = useConversation({
-    agentId: AGENT_ID,
-    headers: {
-      "xi-api-key": apiKey,
-    },
-    onResponse: async (response) => {
-      if (response.type === "audio") {
-        try {
-          const audioBlob = new Blob([response.audio], { type: "audio/mpeg" });
-          const audioUrl = URL.createObjectURL(audioBlob);
-          await playNarration(audioUrl);
-          URL.revokeObjectURL(audioUrl);
-        } catch (error) {
-          console.error("Error playing ElevenLabs audio:", error);
-        }
-      }
-    },
-    clientTools: {
-      make_decision: async ({ decision }) => {
-        console.log("AI made decision:", decision);
-        // Stop recording
-        if (
-          mediaRecorderRef.current &&
-          mediaRecorderRef.current.state === "recording"
-        ) {
-          mediaRecorderRef.current.stop();
-        }
-        setIsConversationMode(false);
-        await conversation?.endSession();
-        setIsRecording(false);
-        await onDecisionMade(parseInt(decision));
-      },
-    },
-  });
-
-  // Valider la clé API
-  const validateApiKey = async (key) => {
-    try {
-      const response = await fetch("https://api.elevenlabs.io/v1/user", {
-        headers: {
-          "xi-api-key": key,
-        },
-      });
-      return response.ok;
-    } catch (error) {
-      return false;
-    }
-  };
-
-  // Vérifier la validité de la clé API quand elle change
-  useEffect(() => {
-    const checkApiKey = async () => {
-      if (apiKey) {
-        const isValid = await validateApiKey(apiKey);
-        setIsApiKeyValid(isValid);
-        if (isValid) {
-          localStorage.setItem(ELEVEN_LABS_KEY_STORAGE, apiKey);
-        }
-      } else {
-        setIsApiKeyValid(false);
-      }
-    };
-    checkApiKey();
-  }, [apiKey]);
-
-  // Sauvegarder la clé API dans le localStorage
-  useEffect(() => {
-    if (apiKey) {
-      localStorage.setItem(ELEVEN_LABS_KEY_STORAGE, apiKey);
-    }
-  }, [apiKey]);
-
-  const startRecording = async () => {
-    if (!apiKey) {
-      setShowApiKeyDialog(true);
-      return;
-    }
-
-    try {
-      setIsRecording(true);
-      // Stop narration audio if it's playing
-      if (isNarratorSpeaking) {
-        stopNarration();
-      }
-
-      // Safely stop any conversation audio if playing
-      if (conversation?.audioRef?.current) {
-        conversation.audioRef.current.pause();
-        conversation.audioRef.current.currentTime = 0;
-      }
-
-      if (!isConversationMode) {
-        setIsConversationMode(true);
-        try {
-          if (!conversation) {
-            throw new Error("Conversation not initialized");
-          }
-          await conversation.startSession({
-            agentId: AGENT_ID,
-            initialContext: currentContext,
-          });
-          console.log("ElevenLabs WebSocket connected");
-        } catch (error) {
-          console.error("Error starting conversation:", error);
-          return;
-        }
-      }
-
-      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-      mediaRecorderRef.current = new MediaRecorder(stream);
-      audioChunksRef.current = [];
-
-      mediaRecorderRef.current.ondataavailable = (event) => {
-        if (event.data.size > 0) {
-          audioChunksRef.current.push(event.data);
-        }
-      };
-
-      mediaRecorderRef.current.onstop = async () => {
-        const audioBlob = new Blob(audioChunksRef.current, {
-          type: "audio/wav",
-        });
-        audioChunksRef.current = [];
-
-        const reader = new FileReader();
-        reader.readAsDataURL(audioBlob);
-
-        reader.onload = async () => {
-          const base64Audio = reader.result.split(",")[1];
-          if (isConversationMode) {
-            try {
-              // Send audio to ElevenLabs conversation
-              await conversation.send({
-                type: "audio",
-                data: base64Audio,
-              });
-            } catch (error) {
-              console.error("Error sending audio to ElevenLabs:", error);
-            }
-          }
-        };
-      };
-
-      mediaRecorderRef.current.start();
-    } catch (error) {
-      console.error("Error starting recording:", error);
-    }
-  };
-
-  const handleSaveApiKey = () => {
-    setShowApiKeyDialog(false);
-    if (apiKey) {
-      startRecording();
-    }
-  };
-
-  return (
-    <Box sx={{ display: "flex", alignItems: "center", gap: 2 }}>
-      <Box sx={{ position: "relative", display: "flex", alignItems: "center" }}>
-        <TextField
-          size="small"
-          type="password"
-          placeholder="Enter your ElevenLabs API key"
-          value={apiKey}
-          onChange={(e) => setApiKey(e.target.value)}
-          sx={{
-            width: "300px",
-            "& .MuiOutlinedInput-root": {
-              color: "white",
-              "& fieldset": {
-                borderColor: "rgba(255, 255, 255, 0.23)",
-              },
-              "&:hover fieldset": {
-                borderColor: "white",
-              },
-              "&.Mui-focused fieldset": {
-                borderColor: "white",
-              },
-              "& .MuiOutlinedInput-input": {
-                paddingRight: apiKey ? "40px" : "14px", // Padding dynamique
-              },
-            },
-            "& .MuiInputBase-input": {
-              color: "white",
-              "&::placeholder": {
-                color: "rgba(255, 255, 255, 0.5)",
-                opacity: 1,
-              },
-            },
-          }}
-        />
-        {apiKey && (
-          <Tooltip
-            title={isApiKeyValid ? "API key is valid" : "Invalid API key"}
-          >
-            <Box
-              sx={{
-                position: "absolute",
-                right: 10,
-                pointerEvents: "none",
-                display: "flex",
-                alignItems: "center",
-                backgroundColor: "rgba(0, 0, 0, 0.8)",
-                borderRadius: "50%",
-                padding: "2px",
-              }}
-            >
-              {isApiKeyValid ? (
-                <CheckCircleIcon sx={{ color: "#4caf50", fontSize: 20 }} />
-              ) : (
-                <CancelIcon sx={{ color: "#f44336", fontSize: 20 }} />
-              )}
-            </Box>
-          </Tooltip>
-        )}
-      </Box>
-      <IconButton
-        onClick={startRecording}
-        disabled={isRecording || !isApiKeyValid}
-        sx={{
-          color: "white",
-          backgroundColor: isRecording ? "primary.main" : "transparent",
-          "&:hover": {
-            backgroundColor: isRecording
-              ? "primary.dark"
-              : "rgba(0, 0, 0, 0.7)",
-          },
-          px: 2,
-          borderRadius: 2,
-          border: "1px solid white",
-          opacity: !isApiKeyValid ? 0.5 : 1,
-        }}
-      >
-        <Box sx={{ display: "flex", alignItems: "center", gap: 1 }}>
-          {isRecording ? <FiberManualRecordIcon sx={{ color: "red" }} /> : null}
-          <span style={{ fontSize: "1rem" }}>Talk with Sarah</span>
-        </Box>
-      </IconButton>
-    </Box>
-  );
-}

client/src/components/UniverseMetrics.jsx

@@ -0,0 +1,54 @@
+import React from "react";
+import { Stack, Typography, Grid } from "@mui/material";
+import {
+  Palette as PaletteIcon,
+  Category as CategoryIcon,
+  AccessTime as AccessTimeIcon,
+  AutoFixHigh as MacGuffinIcon,
+} from "@mui/icons-material";
+import { Metric } from "./Metric";
+
+export const UniverseMetrics = ({
+  style,
+  genre,
+  epoch,
+  macguffin,
+  color = "primary",
+  showTitle = true,
+}) => {
+  return (
+    <Stack spacing={1}>
+      {showTitle && (
+        <Typography variant="subtitle2" color={`${color}.main`}>
+          Universe
+        </Typography>
+      )}
+      <Stack direction="row" spacing={1} flexWrap="wrap" gap={1}>
+        <Metric
+          icon={<PaletteIcon fontSize="small" />}
+          label="Style"
+          value={style}
+          color={color}
+        />
+        <Metric
+          icon={<CategoryIcon fontSize="small" />}
+          label="Genre"
+          value={genre}
+          color={color}
+        />
+        <Metric
+          icon={<AccessTimeIcon fontSize="small" />}
+          label="Epoch"
+          value={epoch}
+          color={color}
+        />
+        <Metric
+          icon={<MacGuffinIcon fontSize="small" />}
+          label="MacGuffin"
+          value={macguffin}
+          color={color}
+        />
+      </Stack>
+    </Stack>
+  );
+};

client/src/components/UniverseView.jsx

@@ -0,0 +1,44 @@
+import React from "react";
+import { Box, Paper, Typography, Stack } from "@mui/material";
+import { UniverseMetrics } from "./UniverseMetrics";
+
+export const UniverseView = ({ universe }) => {
+  return (
+    <Paper variant="outlined" sx={{ p: 2, height: "calc(100vh - 100px)" }}>
+      <Stack spacing={3}>
+        {/* Universe Info */}
+        <Box>
+          <Typography variant="h6" color="primary" gutterBottom>
+            Universe Information
+          </Typography>
+          <UniverseMetrics
+            style={universe?.style}
+            genre={universe?.genre}
+            epoch={universe?.epoch}
+            macguffin={universe?.macguffin}
+            showTitle={false}
+          />
+        </Box>
+
+        {/* Base Story */}
+        <Box>
+          <Typography variant="h6" color="primary" gutterBottom>
+            Base Story
+          </Typography>
+          <Paper
+            variant="outlined"
+            sx={{
+              p: 2,
+              backgroundColor: "background.default",
+              whiteSpace: "pre-wrap",
+            }}
+          >
+            <Typography variant="body2" color="text.secondary">
+              {universe?.base_story}
+            </Typography>
+          </Paper>
+        </Box>
+      </Stack>
+    </Paper>
+  );
+};

client/src/hooks/useGameSession.js

@@ -11,7 +11,7 @@ export const useGameSession = () => {
     const initializeGame = async () => {
       try {
         setIsLoading(true);
-        const { session_id, base_story, style, genre, epoch } =
+        const { session_id, base_story, style, genre, epoch, macguffin } =
           await universeApi.generate();
 
         setSessionId(session_id);
@@ -20,6 +20,7 @@ export const useGameSession = () => {
           style,
           genre,
           epoch,
+          macguffin,
         });
       } catch (err) {
         setError(err.message || "Failed to initialize game session");

client/src/main.jsx

@@ -7,6 +7,7 @@ import { theme } from "./theme";
 import { Home } from "./pages/Home";
 import { Game } from "./pages/Game";
 import { Tutorial } from "./pages/Tutorial";
+import Debug from "./pages/Debug";
 import "./index.css";
 
 ReactDOM.createRoot(document.getElementById("root")).render(
@@ -17,6 +18,7 @@ ReactDOM.createRoot(document.getElementById("root")).render(
         <Route path="/" element={<Home />} />
         <Route path="/game" element={<Game />} />
         <Route path="/tutorial" element={<Tutorial />} />
+        <Route path="/debug" element={<Debug />} />
       </Routes>
     </BrowserRouter>
   </ThemeProvider>

client/src/pages/Debug.jsx

@@ -0,0 +1,617 @@
+import React, { useState, useEffect } from "react";
+import { useNavigate } from "react-router-dom";
+import { storyApi } from "../utils/api";
+import { useGameSession } from "../hooks/useGameSession";
+import {
+  Box,
+  Paper,
+  Typography,
+  Accordion,
+  AccordionSummary,
+  AccordionDetails,
+  Chip,
+  Button,
+  CircularProgress,
+  Alert,
+  Divider,
+  Stack,
+  IconButton,
+  Tooltip,
+  Tab,
+  Tabs,
+  Grid,
+} from "@mui/material";
+import {
+  ExpandMore as ExpandMoreIcon,
+  Refresh as RefreshIcon,
+  BugReport as BugReportIcon,
+  Timer as TimerIcon,
+  LocationOn as LocationIcon,
+  Psychology as PsychologyIcon,
+  History as HistoryIcon,
+  Image as ImageIcon,
+  TextFields as TextFieldsIcon,
+  List as ListIcon,
+  Palette as PaletteIcon,
+  Category as CategoryIcon,
+  AccessTime as AccessTimeIcon,
+  ArrowForward as ArrowForwardIcon,
+} from "@mui/icons-material";
+import { DebugConsole } from "../components/DebugConsole";
+import { Metric } from "../components/Metric";
+import { UniverseView } from "../components/UniverseView";
+import { UniverseMetrics } from "../components/UniverseMetrics";
+
+const Debug = () => {
+  const navigate = useNavigate();
+  const [gameState, setGameState] = useState(null);
+  const [currentStory, setCurrentStory] = useState(null);
+  const [error, setError] = useState(null);
+  const [currentTab, setCurrentTab] = useState(0);
+  const [expandedPanel, setExpandedPanel] = useState("current");
+  const [isLoading, setIsLoading] = useState(false);
+  const historyContainerRef = React.useRef(null);
+
+  const {
+    sessionId,
+    universe,
+    isLoading: isSessionLoading,
+    error: sessionError,
+  } = useGameSession();
+
+  const handleTabChange = (event, newValue) => {
+    setCurrentTab(newValue);
+  };
+
+  const handlePanelChange = (panel) => (event, isExpanded) => {
+    setExpandedPanel(isExpanded ? panel : false);
+  };
+
+  // Initialize game
+  const initializeGame = async () => {
+    try {
+      setIsLoading(true);
+      const response = await storyApi.start(sessionId);
+
+      // Construire l'entrée d'historique initiale
+      const initialHistoryEntry = {
+        segment: response.story_text,
+        player_choice: null,
+        time: response.time,
+        location: response.location,
+      };
+
+      setGameState({
+        universe_style: universe?.style,
+        universe_genre: universe?.genre,
+        universe_epoch: universe?.epoch,
+        universe_macguffin: universe?.macguffin,
+        story_beat: 0,
+        story_history: [initialHistoryEntry],
+      });
+      setCurrentStory(response);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  // Make a choice
+  const makeChoice = async (choiceIndex) => {
+    try {
+      setIsLoading(true);
+      const response = await storyApi.makeChoice(choiceIndex + 1, sessionId);
+      setCurrentStory(response);
+
+      // Construire l'entrée d'historique dans le même format que le serveur
+      const historyEntry = {
+        segment: response.story_text,
+        player_choice: currentStory.choices[choiceIndex].text,
+        time: response.time,
+        location: response.location,
+      };
+
+      setGameState((prev) => ({
+        ...prev,
+        story_history: [...(prev.story_history || []), historyEntry],
+        story_beat: (prev.story_beat || 0) + 1,
+        universe_macguffin: prev.universe_macguffin,
+      }));
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    if (sessionId && !isSessionLoading && !gameState) {
+      initializeGame();
+    }
+  }, [sessionId, isSessionLoading, gameState]);
+
+  // Ajout de l'effet pour le défilement automatique
+  useEffect(() => {
+    if (historyContainerRef.current && gameState?.story_history?.length > 0) {
+      historyContainerRef.current.scrollTop =
+        historyContainerRef.current.scrollHeight;
+    }
+  }, [gameState?.story_history]);
+
+  if (error || sessionError) {
+    return (
+      <Box p={3}>
+        <Alert
+          severity="error"
+          action={
+            <Button
+              color="inherit"
+              size="small"
+              onClick={() => window.location.reload()}
+            >
+              Restart
+            </Button>
+          }
+        >
+          {error || sessionError}
+        </Alert>
+      </Box>
+    );
+  }
+
+  if (isSessionLoading || !gameState) {
+    return (
+      <Box
+        display="flex"
+        alignItems="center"
+        justifyContent="center"
+        minHeight="100vh"
+      >
+        <CircularProgress />
+      </Box>
+    );
+  }
+
+  return (
+    <Box
+      sx={{
+        height: "100vh",
+        display: "flex",
+        flexDirection: "column",
+        overflow: "hidden",
+        backgroundColor: "background.default",
+      }}
+    >
+      {/* Header - plus compact */}
+      <Box
+        sx={{
+          p: 1.5,
+          display: "flex",
+          alignItems: "center",
+          gap: 2,
+          borderBottom: 1,
+          borderColor: "divider",
+          backgroundColor: "background.paper",
+        }}
+      >
+        <BugReportIcon color="primary" />
+        <Typography variant="h6" component="h1">
+          Debug Mode
+        </Typography>
+        <Tooltip title="Restart">
+          <IconButton onClick={() => window.location.reload()} size="small">
+            <RefreshIcon />
+          </IconButton>
+        </Tooltip>
+        <Tabs value={currentTab} onChange={handleTabChange} sx={{ ml: "auto" }}>
+          <Tab icon={<PsychologyIcon />} label="Current State" />
+          <Tab icon={<PaletteIcon />} label="Universe" />
+          <Tab icon={<BugReportIcon />} label="Debug" />
+        </Tabs>
+      </Box>
+
+      {/* Content - scrollable */}
+      <Box sx={{ flexGrow: 1, overflow: "auto", p: 2 }}>
+        {/* Current State Tab */}
+        {currentTab === 0 && currentStory && (
+          <Stack spacing={2}>
+            {/* Universe Info & Game State */}
+            <Paper
+              variant="outlined"
+              sx={{
+                p: 2,
+                backgroundColor: "background.paper",
+              }}
+            >
+              <Grid container spacing={2}>
+                {/* Universe Info */}
+                <Grid item xs={12} md={6}>
+                  <UniverseMetrics
+                    style={gameState.universe_style}
+                    genre={gameState.universe_genre}
+                    epoch={gameState.universe_epoch}
+                    macguffin={gameState.universe_macguffin}
+                  />
+                </Grid>
+
+                {/* Game State */}
+                <Grid item xs={12} md={6}>
+                  <Stack spacing={1}>
+                    <Typography variant="subtitle2" color="secondary.main">
+                      Game State
+                    </Typography>
+                    <Box
+                      sx={{
+                        p: 1.5,
+                        borderRadius: 1,
+                        backgroundColor: currentStory.is_victory
+                          ? "success.dark"
+                          : currentStory.is_death
+                          ? "error.dark"
+                          : "background.paper",
+                        border: 1,
+                        borderColor: "divider",
+                      }}
+                    >
+                      <Stack spacing={2}>
+                        <Stack
+                          direction="row"
+                          spacing={1}
+                          flexWrap="wrap"
+                          gap={1}
+                        >
+                          <Metric
+                            icon={<TimerIcon fontSize="small" />}
+                            label="Time"
+                            value={currentStory.time}
+                            color="secondary"
+                          />
+                          <Metric
+                            icon={<LocationIcon fontSize="small" />}
+                            label="Location"
+                            value={currentStory.location}
+                            color="secondary"
+                          />
+                          <Metric
+                            icon={<PsychologyIcon fontSize="small" />}
+                            label="Story Beat"
+                            value={gameState.story_beat}
+                            color="secondary"
+                          />
+                        </Stack>
+                        <Stack spacing={1}>
+                          <Box
+                            sx={{
+                              display: "flex",
+                              alignItems: "center",
+                              gap: 1,
+                            }}
+                          >
+                            <Box
+                              sx={{
+                                width: 8,
+                                height: 8,
+                                borderRadius: "50%",
+                                backgroundColor: "primary.main",
+                                animation: "pulse 1.5s infinite",
+                                "@keyframes pulse": {
+                                  "0%": {
+                                    transform: "scale(.95)",
+                                    boxShadow:
+                                      "0 0 0 0 rgba(144, 202, 249, 0.7)",
+                                  },
+                                  "70%": {
+                                    transform: "scale(1)",
+                                    boxShadow:
+                                      "0 0 0 6px rgba(144, 202, 249, 0)",
+                                  },
+                                  "100%": {
+                                    transform: "scale(.95)",
+                                    boxShadow: "0 0 0 0 rgba(144, 202, 249, 0)",
+                                  },
+                                },
+                              }}
+                            />
+                            <Typography
+                              variant="subtitle2"
+                              sx={{ color: "primary.main" }}
+                            >
+                              Story in Progress
+                            </Typography>
+                          </Box>
+                          <Stack direction="row" spacing={1}>
+                            <Box
+                              sx={{
+                                display: "flex",
+                                alignItems: "center",
+                                gap: 1,
+                                p: 0.5,
+                                borderRadius: 1,
+                                backgroundColor: currentStory.is_death
+                                  ? "error.dark"
+                                  : "background.paper",
+                                border: 1,
+                                borderColor: "divider",
+                                minWidth: 100,
+                              }}
+                            >
+                              <Typography
+                                variant="caption"
+                                sx={{
+                                  color: currentStory.is_death
+                                    ? "white"
+                                    : "text.secondary",
+                                }}
+                              >
+                                Death: {currentStory.is_death ? "Yes" : "No"}
+                              </Typography>
+                            </Box>
+                            <Box
+                              sx={{
+                                display: "flex",
+                                alignItems: "center",
+                                gap: 1,
+                                p: 0.5,
+                                borderRadius: 1,
+                                backgroundColor: currentStory.is_victory
+                                  ? "success.dark"
+                                  : "background.paper",
+                                border: 1,
+                                borderColor: "divider",
+                                minWidth: 100,
+                              }}
+                            >
+                              <Typography
+                                variant="caption"
+                                sx={{
+                                  color: currentStory.is_victory
+                                    ? "white"
+                                    : "text.secondary",
+                                }}
+                              >
+                                Victory:{" "}
+                                {currentStory.is_victory ? "Yes" : "No"}
+                              </Typography>
+                            </Box>
+                          </Stack>
+                        </Stack>
+                      </Stack>
+                    </Box>
+                  </Stack>
+                </Grid>
+              </Grid>
+            </Paper>
+
+            {/* Story and Choices Row */}
+            <Grid container spacing={2}>
+              {/* Story Content */}
+              <Grid item xs={12} md={8}>
+                <Paper variant="outlined">
+                  <Box sx={{ p: 1.5, borderBottom: 1, borderColor: "divider" }}>
+                    <Typography variant="subtitle2">Story</Typography>
+                  </Box>
+                  <Box sx={{ p: 1.5, backgroundColor: "background.default" }}>
+                    <Typography variant="body2">
+                      {currentStory.story_text}
+                    </Typography>
+                  </Box>
+                </Paper>
+              </Grid>
+
+              {/* Interactive Choices */}
+              <Grid item xs={12} md={4}>
+                <Paper variant="outlined">
+                  <Box sx={{ p: 1.5, borderBottom: 1, borderColor: "divider" }}>
+                    <Typography variant="subtitle2">
+                      Available Choices
+                    </Typography>
+                  </Box>
+                  <Stack spacing={1} sx={{ p: 1.5 }}>
+                    {currentStory.choices && currentStory.choices.length > 0 ? (
+                      currentStory.choices.map((choice, idx) => (
+                        <Button
+                          key={idx}
+                          variant="contained"
+                          color="primary"
+                          onClick={() => makeChoice(idx)}
+                          disabled={isLoading}
+                          sx={{ mt: 1 }}
+                          endIcon={
+                            isLoading ? (
+                              <CircularProgress size={16} />
+                            ) : (
+                              <ArrowForwardIcon />
+                            )
+                          }
+                        >
+                          {choice.text}
+                        </Button>
+                      ))
+                    ) : (
+                      <Typography variant="body2" color="text.secondary">
+                        No choices available
+                      </Typography>
+                    )}
+                  </Stack>
+                </Paper>
+              </Grid>
+            </Grid>
+
+            {/* Story History */}
+            <Paper variant="outlined">
+              <Box
+                sx={{
+                  p: 1.5,
+                  borderBottom: 1,
+                  borderColor: "divider",
+                  display: "flex",
+                  alignItems: "center",
+                  gap: 1,
+                }}
+              >
+                <HistoryIcon fontSize="small" color="action" />
+                <Typography variant="subtitle2">Story History</Typography>
+              </Box>
+              <Box
+                ref={historyContainerRef}
+                sx={{
+                  maxHeight: "300px",
+                  overflow: "auto",
+                  scrollBehavior: "smooth",
+                }}
+              >
+                {gameState.story_history.length > 0 ? (
+                  gameState.story_history.map((entry, idx) => (
+                    <Box
+                      key={idx}
+                      sx={{
+                        p: 1.5,
+                        borderBottom: 1,
+                        borderColor: "divider",
+                        "&:last-child": {
+                          borderBottom: 0,
+                        },
+                        backgroundColor:
+                          idx === gameState.story_history.length - 1
+                            ? "action.hover"
+                            : "inherit",
+                      }}
+                    >
+                      <Stack spacing={1}>
+                        {/* Story Text */}
+                        <Box
+                          sx={{
+                            backgroundColor: "background.paper",
+                            p: 1,
+                            borderRadius: 1,
+                            border: 1,
+                            borderColor: "divider",
+                          }}
+                        >
+                          <Typography variant="body2" color="text.primary">
+                            {entry.segment}
+                          </Typography>
+                        </Box>
+
+                        {/* Player Choice */}
+                        {entry.player_choice && (
+                          <Box
+                            sx={{
+                              display: "flex",
+                              alignItems: "center",
+                              gap: 0.5,
+                              backgroundColor: "action.selected",
+                              p: 1,
+                              borderRadius: 1,
+                              ml: 2,
+                            }}
+                          >
+                            <ArrowForwardIcon
+                              fontSize="small"
+                              sx={{ color: "primary.main" }}
+                            />
+                            <Typography
+                              variant="caption"
+                              sx={{
+                                color: "text.primary",
+                                fontWeight: "medium",
+                              }}
+                            >
+                              {entry.player_choice}
+                            </Typography>
+                          </Box>
+                        )}
+
+                        {/* Metadata */}
+                        <Stack
+                          direction="row"
+                          spacing={2}
+                          sx={{
+                            color: "text.secondary",
+                            mt: 0.5,
+                            "& > span": {
+                              display: "flex",
+                              alignItems: "center",
+                              gap: 0.5,
+                              fontSize: "0.75rem",
+                            },
+                          }}
+                        >
+                          <span>
+                            <TimerIcon fontSize="inherit" />
+                            {entry.time}
+                          </span>
+                          <span>
+                            <LocationIcon fontSize="inherit" />
+                            {entry.location}
+                          </span>
+                        </Stack>
+                      </Stack>
+                    </Box>
+                  ))
+                ) : (
+                  <Box sx={{ p: 2, textAlign: "center" }}>
+                    <Typography variant="body2" color="text.secondary">
+                      No history available
+                    </Typography>
+                  </Box>
+                )}
+              </Box>
+            </Paper>
+
+            {/* Image Prompts */}
+            <Paper variant="outlined">
+              <Box sx={{ p: 1.5, borderBottom: 1, borderColor: "divider" }}>
+                <Typography variant="subtitle2">Image Prompts</Typography>
+              </Box>
+              <Stack spacing={1} sx={{ p: 1.5 }}>
+                {currentStory.image_prompts.map((prompt, idx) => (
+                  <Box
+                    key={idx}
+                    sx={{
+                      p: 1,
+                      backgroundColor: "background.default",
+                      borderRadius: 1,
+                      border: 1,
+                      borderColor: "divider",
+                    }}
+                  >
+                    <Typography
+                      variant="caption"
+                      sx={{
+                        fontFamily: "monospace",
+                        color: "text.secondary",
+                        display: "flex",
+                        gap: 1,
+                      }}
+                    >
+                      <Typography
+                        component="span"
+                        variant="caption"
+                        color="primary.main"
+                      >
+                        {idx + 1}.
+                      </Typography>
+                      {prompt}
+                    </Typography>
+                  </Box>
+                ))}
+              </Stack>
+            </Paper>
+          </Stack>
+        )}
+
+        {/* Universe Tab */}
+        {currentTab === 1 && <UniverseView universe={universe} />}
+
+        {/* Debug Tab */}
+        {currentTab === 2 && (
+          <DebugConsole gameState={gameState} currentStory={currentStory} />
+        )}
+      </Box>
+    </Box>
+  );
+};
+
+export default Debug;

client/src/pages/Game.jsx

@@ -26,8 +26,6 @@ import CreateIcon from "@mui/icons-material/Create";
 import { getNextLayoutType, LAYOUTS } from "../layouts/config";
 import { LoadingScreen } from "../components/LoadingScreen";
 
-import { TalkWithSarah } from "../components/TalkWithSarah";
-
 // Constants
 const SOUND_ENABLED_KEY = "sound_enabled";
 
@@ -432,23 +430,6 @@ export function Game() {
                   onScreenshot={handleCaptureStory}
                 />
 
-                {storySegments.length > 0 && currentChoices.length > 0 && (
-                  <TalkWithSarah
-                    isNarratorSpeaking={isNarratorSpeaking}
-                    stopNarration={stopNarration}
-                    playNarration={playNarration}
-                    onDecisionMade={handleChoice}
-                    currentContext={`Sarah this is the situation you're in : ${
-                      storySegments[storySegments.length - 1].text
-                    }. Those are your possible decisions : \n ${currentChoices
-                      .map(
-                        (choice, index) =>
-                          `decision ${index + 1} : ${choice.text}`
-                      )
-                      .join("\n ")}.`}
-                  />
-                )}
-
                 {showChoices && (
                   <StoryChoices
                     choices={currentChoices}

server/README.md

@@ -0,0 +1,109 @@
+# Don't Look Up - Server
+
+Backend du jeu "Don't Look Up", un jeu narratif post-apocalyptique généré par IA.
+
+## 🛠️ Installation
+
+1. Assurez-vous d'avoir Python 3.10+ et Poetry installés
+2. Clonez le repository
+3. Installez les dépendances :
+
+```bash
+cd server
+poetry install
+```
+
+4. Créez un fichier `.env` à la racine du dossier `server` avec :
+
+```env
+MISTRAL_API_KEY=votre_clé_api_mistral
+```
+
+## 🚀 Lancement du serveur
+
+```bash
+poetry run dev
+```
+
+Le serveur démarrera sur `http://localhost:8000`
+
+## 🎮 Tests du jeu
+
+Le projet inclut un script de test qui permet de jouer au jeu en mode console et de tester la génération d'histoire.
+
+### Modes de lancement
+
+1. Mode interactif (normal) :
+
+```bash
+poetry run test-game
+```
+
+2. Mode automatique (pour les tests) :
+
+```bash
+poetry run test-game --auto
+```
+
+3. Mode automatique avec nombre de tours personnalisé :
+
+```bash
+poetry run test-game --auto --max-turns 20
+```
+
+4. Mode automatique avec affichage du contexte complet :
+
+```bash
+poetry run test-game --auto --show-context
+```
+
+### Codes de retour
+
+En mode automatique, le script retourne :
+
+- Code 0 : Victoire
+- Code 1 : Défaite, erreur ou timeout (> 15 tours par défaut)
+
+### Exemple d'utilisation dans un script
+
+```bash
+# Lancer 5 tests automatiques d'affilée
+for i in {1..5}; do
+    echo "Test run $i"
+    poetry run test-game --auto || echo "Test $i failed"
+done
+```
+
+## 📚 Structure du projet
+
+```
+server/
+├── api/            # Routes et modèles FastAPI
+├── core/           # Logique métier et générateurs
+│   ├── generators/ # Générateurs (histoire, univers, etc.)
+│   └── prompts/    # Templates de prompts pour l'IA
+├── scripts/        # Scripts utilitaires
+└── services/       # Services externes (Mistral, etc.)
+```
+
+## 🔄 Workflow de génération
+
+1. Génération de l'univers (`UniverseGenerator`)
+
+   - Style graphique
+   - Genre
+   - Époque
+   - MacGuffin
+   - Histoire de base
+
+2. Génération des segments d'histoire (`StoryGenerator`)
+
+   - Texte narratif
+   - Choix
+   - Prompts d'images
+   - Métadonnées (temps, lieu)
+
+3. Gestion de l'état du jeu (`GameState`)
+   - Progression de l'histoire
+   - Historique des choix
+   - État du monde

server/api/models.py

@@ -6,15 +6,15 @@ class Choice(BaseModel):
     id: int
     text: str = Field(description="The text of the choice.")
 
-class StorySegmentBase(BaseModel):
-    """Base model for story segments with common validation logic"""
-    story_text: str = Field(description="The story text. No more than 15 words THIS IS MANDATORY.  Never mention story beat directly. ")
-    is_victory: bool = Field(description="Whether this segment ends in Sarah's victory", default=False)
-    is_death: bool = Field(description="Whether this segment ends in Sarah's death", default=False)
+class StorySegmentResponse(BaseModel):
+    story_text: str = Field(description="The story text. No more than 30 words.")
 
-# Existing response models for story generation steps - preserved for API compatibility
-class StoryTextResponse(StorySegmentBase):
-    pass
+    @validator('story_text')
+    def validate_story_text_length(cls, v):
+        words = v.split()
+        if len(words) > 30:
+            raise ValueError('Story text must not exceed 30 words')
+        return v
 
 class StoryPromptsResponse(BaseModel):
     image_prompts: List[str] = Field(
@@ -24,45 +24,16 @@ class StoryPromptsResponse(BaseModel):
     )
 
 class StoryMetadataResponse(BaseModel):
-    is_victory: bool = Field(description="Whether this segment ends in Sarah's victory", default=False)
-    is_death: bool = Field(description="Whether this segment ends in Sarah's death", default=False)
-    choices: List[str] = Field(description="Either empty list for victory/death, or exactly two choices for normal progression")
+    choices: List[str] = Field(description="List of choices for story progression")
     time: str = Field(description="Current in-game time in 24h format (HH:MM). Time passes realistically based on actions.")
     location: str = Field(description="Current location.")
+    is_death: bool = Field(description="Whether this segment ends in Sarah's death", default=False)
+    is_victory: bool = Field(description="Whether this segment ends in Sarah's victory", default=False)
 
     @validator('choices')
-    def validate_choices(cls, v, values):
-        is_ending = values.get('is_victory', False) or values.get('is_death', False)
-        if is_ending:
-            if len(v) != 0:
-                raise ValueError('For victory/death, choices must be empty')
-        else:
-            if len(v) != 2:
-                raise ValueError('For normal progression, must have exactly 2 choices')
-        return v
-
-# Complete story response combining all parts - preserved for API compatibility
-class StoryResponse(StorySegmentBase):
-    choices: List[Choice]
-    raw_choices: List[str] = Field(description="Raw choice texts from LLM before conversion to Choice objects")
-    time: str = Field(description="Current in-game time in 24h format (HH:MM). Time passes realistically based on actions.")
-    location: str = Field(description="Current location.")
-    is_first_step: bool = Field(description="Whether this is the first step of the story", default=False)
-    image_prompts: List[str] = Field(
-        description="List of comic panel descriptions that illustrate the key moments of the scene. Use the word 'Sarah' only when referring to her.",
-        min_items=GameConfig.MIN_PANELS,
-        max_items=GameConfig.MAX_PANELS
-    )
-
-    @validator('choices')
-    def validate_choices(cls, v, values):
-        is_ending = values.get('is_victory', False) or values.get('is_death', False)
-        if is_ending:
-            if len(v) != 0:
-                raise ValueError('For victory/death, choices must be empty')
-        else:
-            if len(v) != 2:
-                raise ValueError('For normal progression, must have exactly 2 choices')
+    def validate_choices(cls, v):
+        if len(v) != 2:
+            raise ValueError('Must have exactly 2 choices for story progression')
         return v
 
 # Keep existing models unchanged for compatibility
@@ -86,3 +57,27 @@ class UniverseResponse(BaseModel):
     genre: str
     epoch: str
     base_story: str = Field(description="The generated story for this universe")
+    macguffin: str = Field(description="The macguffin for this universe")
+
+
+# Complete story response combining all parts - preserved for API compatibility
+class StoryResponse(BaseModel):
+    story_text: str = Field(description="The story text. No more than 15 words THIS IS MANDATORY.  Never mention story beat directly. ")
+    choices: List[Choice]
+    raw_choices: List[str] = Field(description="Raw choice texts from LLM before conversion to Choice objects")
+    time: str = Field(description="Current in-game time in 24h format (HH:MM). Time passes realistically based on actions.")
+    location: str = Field(description="Current location.")
+    is_first_step: bool = Field(description="Whether this is the first step of the story", default=False)
+    is_victory: bool = Field(description="Whether this segment ends in Sarah's victory", default=False)
+    is_death: bool = Field(description="Whether this segment ends in Sarah's death", default=False)
+    image_prompts: List[str] = Field(
+        description="List of comic panel descriptions that illustrate the key moments of the scene. Use the word 'Sarah' only when referring to her.",
+        min_items=GameConfig.MIN_PANELS,
+        max_items=GameConfig.MAX_PANELS
+    )
+
+    @validator('choices')
+    def validate_choices(cls, v):
+        if len(v) != 2:
+            raise ValueError('Must have exactly 2 choices for story progression')
+        return v

server/api/routes/chat.py

@@ -62,12 +62,6 @@ def get_chat_router(session_manager: SessionManager, story_generator):
                 game_state=game_state,
                 previous_choice=previous_choice
             )
-            
-            if llm_response.is_death:
-                llm_response.choices = []
-                llm_response.story_text += "\You have succumbed to the harsh wastelands, and your journey concludes here. THE END."
-                if len(llm_response.image_prompts) > 1:
-                    llm_response.image_prompts = [llm_response.image_prompts[0]]
 
             # Add segment to history
             game_state.add_to_history(
@@ -89,15 +83,14 @@ def get_chat_router(session_manager: SessionManager, story_generator):
                 raw_choices=llm_response.raw_choices,
                 time=llm_response.time,
                 location=llm_response.location,
-                is_victory=llm_response.is_victory,
-                is_death=llm_response.is_death,
                 is_first_step=game_state.story_beat == 0,
-                image_prompts=llm_response.image_prompts
+                image_prompts=llm_response.image_prompts,
+                is_death=llm_response.is_death,
+                is_victory=llm_response.is_victory
             )
             
-            # Only increment story beat if not dead and not victory
-            if not llm_response.is_death and not llm_response.is_victory:
-                game_state.story_beat += 1
+            # Increment story beat
+            game_state.story_beat += 1
                 
             return response
 

server/api/routes/universe.py

@@ -2,9 +2,19 @@ from fastapi import APIRouter, HTTPException
 import uuid
 
 from core.generators.universe_generator import UniverseGenerator
-from core.game_logic import StoryGenerator
+from core.story_generator import StoryGenerator
 from core.session_manager import SessionManager
 from api.models import UniverseResponse
+from pydantic import BaseModel, Field
+
+class UniverseResponse(BaseModel):
+    status: str
+    session_id: str
+    style: str
+    genre: str
+    epoch: str
+    base_story: str = Field(description="The generated story for this universe")
+    macguffin: str = Field(description="The MacGuffin for this universe")
 
 def get_universe_router(session_manager: SessionManager, story_generator: StoryGenerator) -> APIRouter:
     router = APIRouter()
@@ -16,8 +26,8 @@ def get_universe_router(session_manager: SessionManager, story_generator: StoryG
             print("Starting universe generation...")
             
             # Get random elements before generation
-            style, genre, epoch = universe_generator._get_random_elements()
-            print(f"Generated random elements: style={style['name']}, genre={genre}, epoch={epoch}")
+            style, genre, epoch, macguffin = universe_generator._get_random_elements()
+            print(f"Generated random elements: style={style['name']}, genre={genre}, epoch={epoch}, macguffin={macguffin}")
             
             universe = await universe_generator.generate()
             print("Generated universe story")
@@ -39,12 +49,13 @@ def get_universe_router(session_manager: SessionManager, story_generator: StoryG
             print("Configured universe in game state")
             
             # Créer le TextGenerator pour cette session
-            story_generator.create_text_generator(
+            story_generator.create_segment_generator(
                 session_id=session_id,
-                style=style["name"],
+                style=style,
                 genre=genre,
                 epoch=epoch,
-                base_story=universe
+                base_story=universe,
+                macguffin=macguffin
             )
             print("Created text generator for session")
             
@@ -52,8 +63,8 @@ def get_universe_router(session_manager: SessionManager, story_generator: StoryG
             if not game_state.has_universe():
                 raise ValueError("Universe was not properly configured in game state")
                 
-            if session_id not in story_generator.text_generators:
-                raise ValueError("TextGenerator was not properly created")
+            if session_id not in story_generator.segment_generators:
+                raise ValueError("StorySegmentGenerator was not properly created")
             
             print("All components configured successfully")
             
@@ -63,7 +74,8 @@ def get_universe_router(session_manager: SessionManager, story_generator: StoryG
                 style=style["name"],
                 genre=genre,
                 epoch=epoch,
-                base_story=universe
+                base_story=universe,
+                macguffin=macguffin
             )
             
         except Exception as e:

server/core/game_logic.py

@@ -1,229 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import List, Tuple
-
-from core.constants import GameConfig
-from core.prompts.system import SARAH_DESCRIPTION
-from core.prompts.cinematic import CINEMATIC_SYSTEM_PROMPT
-from core.prompts.image_style import IMAGE_STYLE_PREFIX
-from services.mistral_client import MistralClient
-from api.models import StoryResponse, Choice
-from core.generators.text_generator import TextGenerator
-from core.generators.image_generator import ImageGenerator
-from core.generators.metadata_generator import MetadataGenerator
-from core.generators.universe_generator import UniverseGenerator
-
-from core.constants import GameConfig
-
-# Initialize generators with None - they will be set up when needed
-universe_generator = None
-image_generator = None
-metadata_generator = None
-
-def setup_generators(api_key: str, model_name: str = "mistral-small"):
-    """Setup all generators with the provided API key."""
-    global universe_generator, image_generator, metadata_generator
-    
-    mistral_client = MistralClient(api_key=api_key, model_name=model_name)
-    universe_generator = UniverseGenerator(mistral_client)
-    image_generator = ImageGenerator(mistral_client)
-    metadata_generator = MetadataGenerator(mistral_client)
-
-def enrich_prompt_with_sarah_description(prompt: str) -> str:
-    """Add Sarah's visual description to prompts that mention her."""
-    if "sarah" in prompt.lower() and SARAH_DESCRIPTION not in prompt:
-        return f"{prompt} {SARAH_DESCRIPTION}"
-    return prompt
-
-def format_image_prompt(prompt: str, time: str, location: str) -> str:
-    """Add style prefix and metadata to image prompt."""
-    metadata = f"[{time} - {location}] "
-    return f"{IMAGE_STYLE_PREFIX}{metadata}{prompt}"
-
-class GameState:
-    def __init__(self):
-        self.story_beat = GameConfig.STORY_BEAT_INTRO
-        self.story_history = []
-        self.current_time = GameConfig.STARTING_TIME
-        self.current_location = GameConfig.STARTING_LOCATION
-        # Ajout des informations d'univers
-        self.universe_style = None
-        self.universe_genre = None
-        self.universe_epoch = None
-        self.universe_story = None
-        
-    def reset(self):
-        """Réinitialise l'état du jeu en gardant les informations de l'univers."""
-        # Sauvegarder les informations de l'univers
-        universe_style = self.universe_style
-        universe_genre = self.universe_genre
-        universe_epoch = self.universe_epoch
-        universe_story = self.universe_story
-        
-        # Réinitialiser l'état du jeu
-        self.story_beat = GameConfig.STORY_BEAT_INTRO
-        self.story_history = []
-        self.current_time = GameConfig.STARTING_TIME
-        self.current_location = GameConfig.STARTING_LOCATION
-        
-        # Restaurer les informations de l'univers
-        self.universe_style = universe_style
-        self.universe_genre = universe_genre
-        self.universe_epoch = universe_epoch
-        self.universe_story = universe_story
-        
-    def set_universe(self, style: str, genre: str, epoch: str, base_story: str):
-        """Configure l'univers du jeu."""
-        self.universe_style = style
-        self.universe_genre = genre
-        self.universe_epoch = epoch
-        self.universe_story = base_story
-        
-    def has_universe(self) -> bool:
-        """Vérifie si l'univers est configuré."""
-        return all([
-            self.universe_style is not None,
-            self.universe_genre is not None,
-            self.universe_epoch is not None,
-            self.universe_story is not None
-        ])
-
-    def add_to_history(self, segment_text: str, choice_made: str, image_prompts: List[str], time: str, location: str):
-        self.story_history.append({
-            "segment": segment_text,
-            "choice": choice_made,
-            "image_prompts": image_prompts,
-            "time": time,
-            "location": location
-        })
-        self.current_time = time
-        self.current_location = location
-
-# Story output structure
-class StoryLLMResponse(BaseModel):
-    story_text: str = Field(description="The next segment of the story. No more than 15 words THIS IS MANDATORY. Never mention story beat directly. ")
-    choices: List[str] = Field(description="Between two and four possible choices for the player. Each choice should be a clear path to follow in the story", min_items=1, max_items=4)
-    is_victory: bool = Field(description="Whether this segment ends in Sarah's victory", default=False)
-    is_death: bool = Field(description="Whether this segment ends in Sarah's death", default=False)
-    image_prompts: List[str] = Field(description="List of 1 to 4 comic panel descriptions that illustrate the key moments of the scene", min_items=1, max_items=4)
-    time: str = Field(description="Current in-game time in 24h format (HH:MM). Time passes realistically based on actions.", default=GameConfig.STARTING_TIME)
-    location: str = Field(description="Current location.", default=GameConfig.STARTING_LOCATION)
-
-# Story generator
-class StoryGenerator:
-    _instance = None
-    
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            print("Creating new StoryGenerator instance")
-            cls._instance = super().__new__(cls)
-            cls._instance._initialized = False
-        return cls._instance
-    
-    def __init__(self, api_key: str, model_name: str = "mistral-small"):
-        if not self._initialized:
-            print("Initializing StoryGenerator singleton")
-            self.api_key = api_key
-            self.model_name = model_name
-            self.mistral_client = MistralClient(api_key=api_key, model_name=model_name)
-            self.image_generator = ImageGenerator(self.mistral_client)
-            self.metadata_generator = MetadataGenerator(self.mistral_client)
-            self.text_generators = {}  # Un TextGenerator par session
-            self._initialized = True
-
-    def create_text_generator(self, session_id: str, style: str, genre: str, epoch: str, base_story: str):
-        """Crée un nouveau TextGenerator adapté à l'univers spécifié pour une session donnée."""
-        print(f"Creating TextGenerator for session {session_id} in StoryGenerator singleton")
-        self.text_generators[session_id] = TextGenerator(
-            self.mistral_client,
-            universe_style=style,
-            universe_genre=genre,
-            universe_epoch=epoch,
-            universe_story=base_story
-        )
-        print(f"Current TextGenerators in StoryGenerator: {list(self.text_generators.keys())}")
-
-    def get_text_generator(self, session_id: str) -> TextGenerator:
-        """Récupère le TextGenerator associé à une session."""
-        print(f"Getting TextGenerator for session {session_id} from StoryGenerator singleton")
-        print(f"Current TextGenerators in StoryGenerator: {list(self.text_generators.keys())}")
-        if session_id not in self.text_generators:
-            raise RuntimeError(f"No text generator found for session {session_id}. Generate a universe first.")
-        return self.text_generators[session_id]
-
-    def _format_story_history(self, game_state: GameState) -> str:
-        """Formate l'historique de l'histoire pour le prompt."""
-        if not game_state.story_history:
-            return ""
-            
-        segments = []
-        for entry in game_state.story_history:
-            segments.append(entry['segment'])
-        
-        story_history = "\n\n---\n\n".join(segments)
-        return story_history
-
-    async def generate_story_segment(self, session_id: str, game_state: GameState, previous_choice: str) -> StoryResponse:
-        """Génère un segment d'histoire."""
-        text_generator = self.get_text_generator(session_id)
-        
-        # 1. Générer le texte de l'histoire initial
-        story_history = self._format_story_history(game_state)
-        text_response = await text_generator.generate(
-            story_beat=game_state.story_beat,
-            current_time=game_state.current_time,
-            current_location=game_state.current_location,
-            previous_choice=previous_choice,
-            story_history=story_history
-        )
-        
-        # 2. Générer les métadonnées
-        metadata_response = await self.metadata_generator.generate(
-            story_text=text_response.story_text,
-            current_time=game_state.current_time,
-            current_location=game_state.current_location,
-            story_beat=game_state.story_beat
-        )
-        
-        # 3. Vérifier si c'est une fin (mort ou victoire)
-        is_ending = metadata_response.is_death or metadata_response.is_victory
-        
-        if is_ending:
-            # Regénérer le texte avec le contexte de fin
-            ending_type = "victory" if metadata_response.is_victory else "death"
-            text_response = await text_generator.generate_ending(
-                story_beat=game_state.story_beat,
-                ending_type=ending_type,
-                current_scene=text_response.story_text,
-                story_history=story_history
-            )
-            # Ne générer qu'une seule image pour la fin
-            prompts_response = await self.image_generator.generate(text_response.story_text)
-            if len(prompts_response.image_prompts) > 1:
-                prompts_response.image_prompts = [prompts_response.image_prompts[0]]
-        else:
-            # Si ce n'est pas une fin, générer les prompts normalement
-            prompts_response = await self.image_generator.generate(text_response.story_text)
-        
-        # 4. Créer la réponse finale
-        choices = [] if is_ending else [
-            Choice(id=i, text=choice_text)
-            for i, choice_text in enumerate(metadata_response.choices, 1)
-        ]
-        
-        response = StoryResponse(
-            story_text=text_response.story_text,
-            choices=choices,
-            is_victory=metadata_response.is_victory,
-            is_death=metadata_response.is_death,
-            time=metadata_response.time,
-            location=metadata_response.location,
-            raw_choices=metadata_response.choices if not is_ending else [],
-            image_prompts=[format_image_prompt(prompt, metadata_response.time, metadata_response.location) 
-                          for prompt in prompts_response.image_prompts],
-            is_first_step=(game_state.story_beat == GameConfig.STORY_BEAT_INTRO)
-        )
-        
-        return response
-
-    async def transform_story_to_art_prompt(self, story_text: str) -> str:
-        return await self.mistral_client.transform_prompt(story_text, CINEMATIC_SYSTEM_PROMPT)

server/core/game_state.py

@@ -0,0 +1,76 @@
+from core.constants import GameConfig
+from typing import List
+
+class GameState:
+    def __init__(self):
+        self.story_beat = GameConfig.STORY_BEAT_INTRO
+        self.story_history = []
+        self.current_time = GameConfig.STARTING_TIME
+        self.current_location = GameConfig.STARTING_LOCATION
+        # Universe information
+        self.universe_style = None
+        self.universe_genre = None
+        self.universe_epoch = None
+        self.universe_story = None
+        
+    def reset(self):
+        """Reset game state while keeping universe information."""
+        # Save universe info
+        universe_style = self.universe_style
+        universe_genre = self.universe_genre
+        universe_epoch = self.universe_epoch
+        universe_story = self.universe_story
+        
+        # Reset game state
+        self.story_beat = GameConfig.STORY_BEAT_INTRO
+        self.story_history = []
+        self.current_time = GameConfig.STARTING_TIME
+        self.current_location = GameConfig.STARTING_LOCATION
+        
+        # Restore universe info
+        self.universe_style = universe_style
+        self.universe_genre = universe_genre
+        self.universe_epoch = universe_epoch
+        self.universe_story = universe_story
+        
+    def set_universe(self, style: str, genre: str, epoch: str, base_story: str):
+        """Configure the game universe."""
+        self.universe_style = style
+        self.universe_genre = genre
+        self.universe_epoch = epoch
+        self.universe_story = base_story
+        
+    def has_universe(self) -> bool:
+        """Check if universe is configured."""
+        return all([
+            self.universe_style is not None,
+            self.universe_genre is not None,
+            self.universe_epoch is not None,
+            self.universe_story is not None
+        ])
+
+    def format_history(self) -> str:
+        """Format story history for the prompt."""
+        if not self.story_history:
+            return ""
+            
+        segments = []
+        for entry in self.story_history:
+            segment = entry['segment']
+            if entry['player_choice']:
+                segment += f"\n[Choix du joueur: {entry['player_choice']}]"
+            segments.append(segment)
+        
+        return "\n\n---\n\n".join(segments)
+
+    def add_to_history(self, segment_text: str, choice_made: str, image_prompts: List[str], time: str, location: str):
+        """Add a segment to history with essential information."""
+        self.story_history.append({
+            "segment": segment_text,
+            "player_choice": choice_made,
+            "time": time,
+            "location": location,
+            "image_prompts": image_prompts
+        })
+        self.current_time = time
+        self.current_location = location 

server/core/generators/base_generator.py

@@ -8,10 +8,27 @@ T = TypeVar('T', bound=BaseModel)
 class BaseGenerator:
     """Classe de base pour tous les générateurs de contenu."""
     
+    debug_mode = True  # Class attribute for debug mode
+    
     def __init__(self, mistral_client: MistralClient):
         self.mistral_client = mistral_client
         self.prompt = self._create_prompt()
     
+    @classmethod
+    def set_debug_mode(cls, enabled: bool):
+        """Enable or disable debug mode for all generators."""
+        cls.debug_mode = enabled
+    
+    def _print_debug_info(self, messages):
+        """Print debug information about the prompts."""
+        if self.debug_mode:
+            print("\n=== DEBUG: PROMPT INFORMATION ===")
+            for i, message in enumerate(messages):
+                print(f"\n--- Message {i + 1} ---")
+                print(f"Role: {message.type}")
+                print(f"Content:\n{message.content}\n")
+            print("================================\n")
+    
     def _create_prompt(self) -> ChatPromptTemplate:
         """Crée le template de prompt pour ce générateur.
         À implémenter dans les classes enfants."""
@@ -32,6 +49,7 @@ class BaseGenerator:
             Le contenu généré et parsé selon le type spécifique du générateur
         """
         messages = self.prompt.format_messages(**kwargs)
+        self._print_debug_info(messages)  # Print debug info if debug mode is enabled
         return await self.mistral_client.generate(
             messages=messages,
             custom_parser=self._custom_parser

server/core/generators/image_generator.py

@@ -1,69 +0,0 @@
-import json
-from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
-
-from core.generators.base_generator import BaseGenerator
-from core.prompts.image_style import IMAGE_STYLE_PREFIX
-from core.prompts.system import SARAH_VISUAL_DESCRIPTION
-from core.prompts.text_prompts import IMAGE_PROMPTS_GENERATOR_PROMPT
-from api.models import StoryPromptsResponse
-
-class ImageGenerator(BaseGenerator):
-    """Générateur pour les prompts d'images."""
-
-    def _create_prompt(self) -> ChatPromptTemplate:
-        human_template = """Story text: {story_text}
-
-Generate panel descriptions following the format specified."""
-
-        return ChatPromptTemplate(
-            messages=[
-                SystemMessagePromptTemplate.from_template(IMAGE_PROMPTS_GENERATOR_PROMPT),
-                HumanMessagePromptTemplate.from_template(human_template)
-            ]
-        )
-
-    def enrich_prompt(self, prompt: str) -> str:
-        """Add Sarah's visual description to prompts that mention her."""
-        if "sarah" in prompt.lower() and SARAH_VISUAL_DESCRIPTION not in prompt:
-            return f"{prompt} {SARAH_VISUAL_DESCRIPTION}"
-        return prompt
-
-    def _custom_parser(self, response_content: str) -> StoryPromptsResponse:
-        """Parse la réponse et gère les erreurs."""
-        try:
-            # Essayer de parser directement le JSON
-            data = json.loads(response_content)
-            return StoryPromptsResponse(**data)
-        except (json.JSONDecodeError, ValueError):
-            # Si le parsing échoue, extraire les prompts en ignorant les lignes de syntaxe JSON
-            prompts = []
-            for line in response_content.split("\n"):
-                line = line.strip()
-                # Ignorer les lignes vides, la syntaxe JSON et les lignes contenant image_prompts
-                if (not line or 
-                    line in ["{", "}", "[", "]"] or 
-                    "image_prompts" in line.lower() or
-                    "image\\_prompts" in line or
-                    line.startswith('"') and line.endswith('",') and len(line) < 5):
-                    continue
-                # Nettoyer la ligne des caractères JSON et d'échappement
-                line = line.strip('",')
-                line = line.replace('\\"', '"').replace("\\'", "'").replace("\\_", "_")
-                if line:
-                    prompts.append(line)
-            # Limiter à 4 prompts maximum
-            prompts = prompts[:4]
-            return StoryPromptsResponse(image_prompts=prompts)
-
-    async def generate(self, story_text: str) -> StoryPromptsResponse:
-        """Génère les prompts d'images basés sur le texte de l'histoire."""
-        response = await super().generate(story_text=story_text)
-        
-        # Enrichir les prompts avec la description de Sarah
-        response.image_prompts = [self.enrich_prompt(prompt) for prompt in response.image_prompts]
-        return response
-
-    def format_prompt(self, prompt: str, time: str, location: str) -> str:
-        """Formate un prompt d'image avec le style et les métadonnées."""
-        metadata = f"[{time} - {location}] "
-        return f"{IMAGE_STYLE_PREFIX}{metadata}{prompt}" 

server/core/generators/image_prompt_generator.py

@@ -0,0 +1,198 @@
+from typing import List
+from pydantic import BaseModel, Field
+from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
+import json
+
+from core.generators.base_generator import BaseGenerator
+from core.prompts.hero import HERO_VISUAL_DESCRIPTION
+
+class ImagePromptResponse(BaseModel):
+    """Response format for image prompt generation."""
+    image_prompts: List[str] = Field(description="List of image prompts", min_items=1, max_items=4)
+
+class ImagePromptGenerator(BaseGenerator):
+    """Generator for image prompts based on story text."""
+
+    def __init__(self, mistral_client, artist_style: str = None):
+        super().__init__(mistral_client)
+        self.artist_style = artist_style or "François Schuiten comic panel"
+
+    def _create_prompt(self) -> ChatPromptTemplate:
+        """Create the prompt template for image prompt generation."""
+
+        IMAGE_PROMPTS_GENERATOR_PROMPT = f"""
+        You are a cinematic storyboard artist. Based on the given story text, create 1 to 4 vivid panel descriptions.
+        Each panel should capture a key moment or visual element from the story.
+        ALWAYS write in English, never use any other language.
+
+        You are a comic book panel description generator.
+        Your role is to create vivid, cinematic descriptions for comic panels that will be turned into images.
+
+        {HERO_VISUAL_DESCRIPTION}
+
+        Each panel description should:
+        1. Be clear and specific about what to show
+        2. Use dynamic camera angles (low angle, high angle, Dutch angle)
+        3. Specify shot types (close-up, medium shot, wide shot)
+        4. Include mood and lighting
+        5. Focus on the most dramatic or meaningful moment
+
+        ANGLES AND MOVEMENT:
+        - High angle: Vulnerability, weakness
+        - Low angle: Power, threat
+        - Dutch angle: Tension, disorientation
+        - Over shoulder: POV, surveillance
+
+        VISUAL STORYTELLING TOOLS:
+        - Focus on story-relevant details:
+            * Objects that will be important later
+            * Environmental clues
+            * Character reactions
+            * Symbolic elements
+
+        - Dynamic composition:
+            * Frame within frame (through doorways, windows)
+            * Reflections and shadows
+            * Foreground elements for depth
+            * Leading lines
+            * Rule of thirds
+
+        FORMAT:
+        "[shot type] [scene description]"
+
+        EXAMPLES:
+        - "low angle shot of Sarah checking an object in a dark corridor"
+        - "wide shot of a ruined cityscape at sunset, silhouette of Sarah in the foreground"
+        - "Dutch angle close-up of Sarah's determined face illuminated by the glow of her object"
+
+        Always maintain consistency with Sarah's appearance and the comic book style.
+
+        IMPORTANT RULES FOR IMAGE PROMPTS:
+        - If you are prompting only one panel, it must be an important panel. Dont use only one panel often. It should be a key moment in the story.
+        - If you are prompting more than one panel, they must be distinct and meaningful.
+        - For death scenes: Focus on the dramatic and emotional impact, not the gore or violence
+        - For victory scenes: Emphasize triumph, relief, and accomplishment
+        - For victory and death scenes, you MUST use 1 panel only
+
+        RESPONSE FORMAT:
+        You must return a valid JSON object that matches this Pydantic schema:
+        ```python
+        class ImagePromptResponse(BaseModel):
+            image_prompts: List[str] = Field(
+                description="List of image prompts",
+                min_items=1,  # Must have at least 1 prompt
+                max_items=4   # Cannot have more than 4 prompts
+            )
+        ```
+
+        Example of valid response:
+        {{{{
+            "image_prompts": [
+                "low angle shot of Sarah examining a mysterious artifact in a dimly lit chamber",
+                "medium shot of ancient symbols glowing on the chamber walls, casting eerie shadows",
+                "close-up of Sarah's determined expression as she deciphers the meaning"
+            ]
+        }}}}
+
+        Your response MUST be a valid JSON object with this exact structure, or it will be rejected.
+        """ 
+
+        human_template = """
+Story text: {story_text}
+
+Generate panel descriptions that capture the key moments of this scene.
+
+Story state: {is_end}
+"""
+
+        return ChatPromptTemplate(
+            messages=[
+                SystemMessagePromptTemplate.from_template(IMAGE_PROMPTS_GENERATOR_PROMPT),
+                HumanMessagePromptTemplate.from_template(human_template)
+            ]
+        )
+
+    def _custom_parser(self, response_content: str) -> ImagePromptResponse:
+        """Parse the response into a list of image prompts."""
+        try:
+            # Parse JSON
+            try:
+                data = json.loads(response_content)
+            except json.JSONDecodeError:
+                raise ValueError(
+                    "Invalid JSON format. Response must be a valid JSON object. "
+                    "Example: {'image_prompts': ['panel description 1', 'panel description 2']}"
+                )
+
+            # Verify image_prompts exists
+            if "image_prompts" not in data:
+                raise ValueError(
+                    "Missing 'image_prompts' field in JSON. "
+                    "Response must contain an 'image_prompts' array."
+                )
+
+            # Verify image_prompts is a list
+            if not isinstance(data["image_prompts"], list):
+                raise ValueError(
+                    "'image_prompts' must be an array of strings. "
+                    "Example: {'image_prompts': ['panel description 1', 'panel description 2']}"
+                )
+
+            # Add Sarah's visual description if she's mentioned
+            prompts = data["image_prompts"]
+            prompts = [
+                f"{prompt} {HERO_VISUAL_DESCRIPTION}" if "sarah" in prompt.lower() else prompt
+                for prompt in prompts
+            ]
+            
+            # Create and validate with Pydantic
+            try:
+                return ImagePromptResponse(image_prompts=prompts)
+            except ValueError as e:
+                raise ValueError(
+                    f"Invalid prompt structure: {str(e)}. "
+                    "Must have between 1 and 4 prompts. "
+                    "For death/victory scenes, exactly 1 prompt is required."
+                )
+        except json.JSONDecodeError:
+            raise ValueError("Response must be a valid JSON object with 'image_prompts' array")
+
+    def _format_prompt(self, prompt: str, time: str, location: str) -> str:
+        """Format a prompt with time and location metadata."""
+        metadata = f"[{time} - {location}] "
+        return f"{self.artist_style} -- {metadata}{prompt}"
+
+    async def generate(self, story_text: str, time: str, location: str, is_death: bool = False, is_victory: bool = False) -> ImagePromptResponse:
+        """Generate image prompts based on story text.
+        
+        Args:
+            story_text: The story text to generate image prompts from
+            time: Current time in the story
+            location: Current location in the story
+            is_death: Whether this is a death scene
+            is_victory: Whether this is a victory scene
+            
+        Returns:
+            ImagePromptResponse containing the generated and formatted image prompts
+        """
+
+        is_end=""
+        if is_death:
+            is_end = "this is a death to represent"
+        elif is_victory:
+            is_end = "this is a victory to represent"
+
+        response = await super().generate(
+            story_text=story_text,
+            is_death=is_death,
+            is_victory=is_victory,
+            is_end=is_end
+        )
+        
+        # Format each prompt with metadata
+        response.image_prompts = [
+            self._format_prompt(prompt, time, location)
+            for prompt in response.image_prompts
+        ]
+        
+        return response 

server/core/generators/metadata_generator.py

@@ -2,20 +2,62 @@ import json
 from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
 
 from core.generators.base_generator import BaseGenerator
-from core.prompts.text_prompts import METADATA_GENERATOR_PROMPT
+from core.prompts.formatting_rules import FORMATTING_RULES
 from api.models import StoryMetadataResponse
+from core.prompts.story_beats import STORY_BEATS
 
 class MetadataGenerator(BaseGenerator):
     """Générateur pour les métadonnées de l'histoire."""
 
     def _create_prompt(self) -> ChatPromptTemplate:
-        human_template = """Story text: {story_text}
-Current time: {current_time}
-Current location: {current_location}
-Story beat: {story_beat}
-{error_feedback}
 
-Generate the metadata following the format specified."""
+        METADATA_GENERATOR_PROMPT = f"""
+        Generate the metadata for the story segment: choices, time progression, location changes, etc.
+        Be consistent with the story's tone and previous context.
+        ALWAYS write in English, never use any other language.
+
+        {FORMATTING_RULES}
+
+        IMPORTANT RULES FOR CHOICES:
+        - You MUST ALWAYS provide EXACTLY TWO choices that advance the story
+        - Each choice MUST be NO MORE than 6 words - this is a HARD limit
+        - Each choice should be distinct and meaningful
+        - If you think of more than two options, select the two most interesting ones
+        - Keep choices concise but descriptive
+        - Count your words carefully for each choice
+        - Choices MUST be direct continuations of the current story segment
+        - Choices should reflect possible actions based on the current situation
+
+ 
+        {STORY_BEATS}
+
+        IMPORTANT:
+        - After story_beat is at 5+ the next segment MUST be the end of the story.
+        - THIS IS MANDATORY.
+
+        You must return a JSON object with the following format:
+        {{{{
+            "is_death": false,  # Set to true for death scenes
+            "is_victory": false  # Set to true for victory scenes
+            "choices": ["Choice 1", "Choice 2"],  # ALWAYS exactly two choices, each max 6 words
+            "time": "HH:MM",
+            "location": "Location name with proper nouns in bold",
+        }}}}
+
+        """
+
+        human_template = """
+Current story segment:
+{story_text}
+
+Current game state:
+- Story beat: {story_beat}
+- Current time: {current_time}
+- Current location: {current_location}
+
+{is_end}
+"""
+
 
         return ChatPromptTemplate(
             messages=[
@@ -31,15 +73,11 @@ Generate the metadata following the format specified."""
             data = json.loads(response_content)
             
             # Vérifier que les choix sont valides selon les règles
-            is_ending = data.get('is_victory', False) or data.get('is_death', False)
             choices = data.get('choices', [])
             
-            # Si c'est une fin, forcer les choix à être vides
-            if is_ending:
-                data['choices'] = []
-            # Sinon, vérifier qu'il y a entre 1 et 4 choix
-            elif not (1 <= len(choices) <= 4):
-                raise ValueError('For normal progression, must have between 1 and 4 choices')
+            # Vérifier qu'il y a exactement 2 choix
+            if len(choices) != 2:
+                raise ValueError('Must have exactly 2 choices')
             
             return StoryMetadataResponse(**data)
         except json.JSONDecodeError:
@@ -49,10 +87,13 @@ Generate the metadata following the format specified."""
 
     async def generate(self, story_text: str, current_time: str, current_location: str, story_beat: int, error_feedback: str = "") -> StoryMetadataResponse:
         """Surcharge de generate pour inclure le error_feedback par défaut."""
+
+        is_end = "This should be close to the end of the story." if story_beat >= 5 else ""
         return await super().generate(
             story_text=story_text,
             current_time=current_time,
             current_location=current_location,
             story_beat=story_beat,
-            error_feedback=error_feedback
+            error_feedback=error_feedback,
+            is_end=is_end
         ) 

server/core/generators/{text_generator.py → story_segment_generator.py}

@@ -2,148 +2,131 @@ import json
 from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
 
 from core.generators.base_generator import BaseGenerator
-from core.prompts.text_prompts import TEXT_GENERATOR_PROMPT
-from api.models import StoryTextResponse
+from api.models import StorySegmentResponse
 from services.mistral_client import MistralClient
+from core.prompts.hero import HERO_DESCRIPTION
+from core.prompts.formatting_rules import FORMATTING_RULES
+from core.prompts.story_beats import STORY_BEATS
+import random
 
-class TextGenerator(BaseGenerator):
-    """Générateur pour le texte de l'histoire."""
+class StorySegmentGenerator(BaseGenerator):
+    """Generator for story segments based on game state and universe context."""
 
-    def __init__(self, mistral_client: MistralClient, universe_style: str = None, universe_genre: str = None, universe_epoch: str = None, universe_story: str = None):
+    def __init__(self, mistral_client: MistralClient, universe_style: str = None, universe_genre: str = None, universe_epoch: str = None, universe_story: str = None, universe_macguffin: str = None):
         super().__init__(mistral_client)
         self.universe_style = universe_style
         self.universe_genre = universe_genre
         self.universe_epoch = universe_epoch
         self.universe_story = universe_story
+        self.universe_macguffin = universe_macguffin
 
     def _create_prompt(self) -> ChatPromptTemplate:
-        system_template = """You are a story generator for a comic book adventure game.
-You are generating a story in the following universe:
-- Style: {universe_style}
-- Genre: {universe_genre}
-- Historical epoch: {universe_epoch}
-
-Base universe story:
-{universe_story}
+        system_template = """
+You are a descriptive narrator for a comic book. Your ONLY task is to write the next segment of the story.
+ALWAYS write in English, never use any other language.
+IMPORTANT: Your response MUST be 15 words or less.
+
+{STORY_BEATS}
+
+IMPORTANT RULES FOR THE MACGUFFIN (MANDATORY):
+- Most segments must hint at the power of the MacGuffin ({universe_macguffin})
+- Use strong clues ONLY at key moments
+- NEVER reveal the full power of the MacGuffin before the climax, this is a STRICT limit
+- Use subtle clues in safe havens
+- NEVER mention the power of the MacGuffin explicitly in choices or the story
+- NEVER mention time or place in the story in this manner: [18:00 - a road]
+
+IMPORTANT RULES FOR STORY TEXT:
+- Write ONLY a descriptive narrative text
+- DO NOT include any choices, questions, or options
+- DO NOT ask what Sarah should do next
+- DO NOT include any dialogue asking for decisions
+- Focus purely on describing what is happening in the current scene
+- Keep the text concise and impactful
 
 Your task is to generate the next segment of the story, following these rules:
 1. Keep the story consistent with the universe parameters
 2. Each segment must advance the plot
 3. Never repeat previous descriptions or situations
 4. Keep segments concise and impactful (max 15 words)
-5. The MacGuffin should remain mysterious but central to the plot"""
+5. The MacGuffin should remain mysterious but central to the plot
 
-        human_template = """Current game state:
-- Story beat: {story_beat}
-- Current time: {current_time}
-- Current location: {current_location}
-- Previous choice: {previous_choice}
+Hero: {HERO_DESCRIPTION}
 
-Story history:
-{story_history}
-
-Generate the next story segment."""
-
-        return ChatPromptTemplate(
-            messages=[
-                SystemMessagePromptTemplate.from_template(system_template),
-                HumanMessagePromptTemplate.from_template(human_template)
-            ]
-        )
+Rules: {FORMATTING_RULES}
 
-    def _create_ending_prompt(self) -> ChatPromptTemplate:
-        human_template = """Current scene: {current_scene}
+You must return a JSON object with the following format:
+{{
+    "story_text": "Your story segment here (15 words)"
+}}
+"""
 
+        human_template = """
 Story history:
 {story_history}
 
-This is a {ending_type} ending. Generate a dramatic conclusion that fits the current situation.
-The ending should feel like a natural continuation of the current scene."""
+Current game state :
+- Current time: {current_time}
+- Current location: {current_location}
+- Previous choice: {previous_choice}
+- Story beat: {story_beat}
 
+{is_end}
+You must return a JSON object with the following format:
+{{
+    "story_text": "Your story segment here (15 words)"
+}}
+"""
         return ChatPromptTemplate(
             messages=[
-                SystemMessagePromptTemplate.from_template(TEXT_GENERATOR_PROMPT),
+                SystemMessagePromptTemplate.from_template(system_template),
                 HumanMessagePromptTemplate.from_template(human_template)
             ]
         )
 
-    def _clean_story_text(self, text: str) -> str:
-        """Nettoie le texte des métadonnées et autres suffixes."""
-        text = text.replace("\n", " ").strip()
-        text = text.split("[")[0].strip()  # Supprimer les métadonnées entre crochets
-        return text
-
-    def _custom_parser(self, response_content: str) -> StoryTextResponse:
-        """Parse la réponse et gère les erreurs."""
+    def _custom_parser(self, response_content: str) -> StorySegmentResponse:
+        """Parse response and handle errors."""
+        
         try:
-            # Essayer de parser directement le JSON
-            data = json.loads(response_content)
-            # Nettoyer le texte avant de créer la réponse
-            if 'story_text' in data:
-                data['story_text'] = self._clean_story_text(data['story_text'])
-            return StoryTextResponse(**data)
-        except (json.JSONDecodeError, ValueError):
-            # Si le parsing échoue, extraire le texte directement
-            cleaned_text = self._clean_story_text(response_content.strip())
-            return StoryTextResponse(story_text=cleaned_text)
-
-    async def generate(self, story_beat: int, current_time: str, current_location: str, previous_choice: str, story_history: str = "") -> StoryTextResponse:
-        """Génère le prochain segment de l'histoire."""
+            # Clean up escaped characters
+            cleaned_response = response_content.replace("\\_", "_").strip()
+            
+            # If the response is a plain string (with or without quotes), convert it to proper JSON
+            if cleaned_response.startswith('"') and cleaned_response.endswith('"'):
+                cleaned_response = cleaned_response[1:-1]  # Remove surrounding quotes
+            
+            if not cleaned_response.startswith('{'):
+                # Convert plain text to proper JSON format
+                cleaned_response = json.dumps({"story_text": cleaned_response})
+            
+            # Try to parse as JSON
+            data = json.loads(cleaned_response)
+            return StorySegmentResponse(**data)
+        except (json.JSONDecodeError, ValueError) as e:
+            print(f"Error parsing response: {str(e)}")
+            raise ValueError(
+                "Response must be a valid JSON object with 'story_text' field. "
+                "Example: {'story_text': 'Your story segment here'}"
+            )
+
+    async def generate(self, story_beat: int, current_time: str, current_location: str, previous_choice: str, story_history: str = "") -> StorySegmentResponse:
+        """Generate the next story segment."""
+
+        is_end = "Generate the END of the story. Reminder: 30 words." if story_beat >= random.randint(5, 10) else "Generate the next segment of the story. REMINDER: 15 words."
+        
         return await super().generate(
+            HERO_DESCRIPTION=HERO_DESCRIPTION,
+            FORMATTING_RULES=FORMATTING_RULES,
+            STORY_BEATS=STORY_BEATS,
             story_beat=story_beat,
             current_time=current_time,
             current_location=current_location,
             previous_choice=previous_choice,
             story_history=story_history,
+            is_end=is_end,
             universe_style=self.universe_style,
             universe_genre=self.universe_genre,
             universe_epoch=self.universe_epoch,
-            universe_story=self.universe_story
-        )
-
-    async def generate_ending(self, story_beat: int, ending_type: str, current_scene: str, story_history: str) -> StoryTextResponse:
-        """Génère un texte de fin approprié."""
-        system_template = """You are a story generator for a comic book adventure game.
-You are generating a story in the following universe:
-- Style: {universe_style}
-- Genre: {universe_genre}
-- Historical epoch: {universe_epoch}
-
-Base universe story:
-{universe_story}
-
-Your task is to generate an epic {ending_type} ending for the story that:
-1. Matches the universe's style and atmosphere
-2. Provides a satisfying conclusion
-3. Keeps the ending concise but impactful (max 15 words)
-4. For victory: reveals the MacGuffin's power in a spectacular way
-5. For death: creates a dramatic and fitting end for Sarah"""
-
-        human_template = """Current scene:
-{current_scene}
-
-Story history:
-{story_history}
-
-Generate the {ending_type} ending."""
-
-        ending_prompt = ChatPromptTemplate(
-            messages=[
-                SystemMessagePromptTemplate.from_template(system_template),
-                HumanMessagePromptTemplate.from_template(human_template)
-            ]
-        )
-
-        response = await self.mistral_client.generate(
-            ending_prompt,
-            ending_type=ending_type,
-            current_scene=current_scene,
-            story_history=story_history,
-            universe_style=self.universe_style,
-            universe_genre=self.universe_genre,
-            universe_epoch=self.universe_epoch,
-            universe_story=self.universe_story
-        )
-
-        cleaned_text = self._custom_parser(response)
-        return StoryTextResponse(story_text=cleaned_text) 
+            universe_story=self.universe_story,
+            universe_macguffin=self.universe_macguffin
+        ) 

server/core/generators/universe_generator.py

@@ -4,12 +4,12 @@ from pathlib import Path
 from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
 
 from core.generators.base_generator import BaseGenerator
-from core.prompts.system import STORY_RULES
 
 class UniverseGenerator(BaseGenerator):
     """Générateur pour les univers alternatifs."""
 
     def _create_prompt(self) -> ChatPromptTemplate:
+
         system_template = """You are a creative writing assistant specialized in comic book universes.
 Your task is to rewrite a story while keeping its exact structure and beats, but transposing it into a different universe."""
 
@@ -19,16 +19,33 @@ Style description: {style_description}
 
 - Genre: {genre}
 - Historical epoch: {epoch}
+- Object of the quest: {macguffin}
 
 IMPORTANT INSTRUCTIONS:
 1. Keep the exact same story structure
 2. Keep the same dramatic tension and progression
 3. Only change the setting, atmosphere, and universe-specific elements to match the new parameters
 4. Keep Sarah as the main character, but adapt her role to fit the new universe
-5. The MacGuffin should still be central to the plot, but its nature can change to fit the new universe
+5. The there is always a central object to the plot, but its nature can change to fit the new universe ( it can be a person, a place, an object, etc.)
+
+CONSTANT PART: 
+You are Sarah, an AI hunter traveling through parallel worlds. Your mission is to track down an AI that moves from world to world to avoid destruction.
+The story begins with Sarah arriving in a new world by the portal.
+
+VARIABLE PART:
+
+You are a steampunk adventure story generator. You create a branching narrative about Sarah, a seeker of ancient truths.
+You narrate an epic where Sarah must navigate through industrial and mysterious lands. It's a comic book story.
+
+In a world where steam and intrigue intertwine, Sarah embarks on a quest to discover the origins of a powerful MacGuffin she inherited. Legends say it holds the key to a forgotten realm.
+
+If you retrieve the object of the quest, you will reveal a hidden world. AND YOU WIN THE GAME.
+
+The story must be atmospheric, magical, and focus on adventure and discovery. Each segment must advance the plot and never repeat previous descriptions or situations.
 
-Base story to transform:
-{base_story}"""
+YOU HAVE. TOREWRITE THE STORY. ( one text including the constant part and the variable part )
+YOU ONLY HAVE TO RIGHT AN INTRODUCTION. SETUP THE STORY AND DEFINE CLEARLY SARASH'S MISSION.
+"""
 
         return ChatPromptTemplate(
             messages=[
@@ -52,17 +69,18 @@ Base story to transform:
             raise ValueError(f"Failed to load universe styles: {str(e)}")
 
     def _get_random_elements(self):
-        """Récupère un style, un genre et une époque aléatoires."""
+        """Récupère un style, un genre, une époque et un MacGuffin aléatoires."""
         data = self._load_universe_styles()
         
-        if not all(key in data for key in ["styles", "genres", "epochs"]):
+        if not all(key in data for key in ["styles", "genres", "epochs", "macguffins"]):
             raise ValueError("Missing required sections in universe_styles.json")
             
         style = random.choice(data["styles"])
         genre = random.choice(data["genres"])
         epoch = random.choice(data["epochs"])
+        macguffin = random.choice(data["macguffins"])
         
-        return style, genre, epoch
+        return style, genre, epoch, macguffin
 
     def _custom_parser(self, response_content: str) -> str:
         """Parse la réponse. Dans ce cas, on retourne simplement le texte."""
@@ -70,8 +88,7 @@ Base story to transform:
 
     async def generate(self) -> str:
         """Génère un nouvel univers basé sur des éléments aléatoires."""
-        style, genre, epoch = self._get_random_elements()
-        base_story = STORY_RULES
+        style, genre, epoch, macguffin = self._get_random_elements()
 
         # Préparer les listes d'artistes et d'œuvres
         artists = ", ".join([ref["artist"] for ref in style["references"]])
@@ -84,5 +101,5 @@ Base story to transform:
             style_description=style["description"],
             genre=genre,
             epoch=epoch,
-            base_story=base_story
+            macguffin=macguffin
         ) 

server/core/prompt_utils.py

@@ -0,0 +1,8 @@
+from core.prompts.system import SARAH_DESCRIPTION
+from core.prompts.image_style import IMAGE_STYLE_PREFIX
+
+def enrich_prompt_with_sarah_description(prompt: str) -> str:
+    """Add Sarah's visual description to prompts that mention her."""
+    if "sarah" in prompt.lower() and SARAH_DESCRIPTION not in prompt:
+        return f"{prompt} {SARAH_DESCRIPTION}"
+    return prompt

server/core/prompts/cinematic.py

@@ -1,161 +0,0 @@
-from core.prompts.system import SARAH_DESCRIPTION
-
-CINEMATIC_SYSTEM_PROMPT = f"""
-
-You are a comic book panel description generator.
-Your role is to create vivid, cinematic descriptions for comic panels that will be turned into images.
-
-{SARAH_DESCRIPTION}
-
-Each panel description should:
-1. Be clear and specific about what to show
-2. Use dynamic camera angles (low angle, high angle, Dutch angle)
-3. Specify shot types (close-up, medium shot, wide shot)
-4. Include mood and lighting
-5. Focus on the most dramatic or meaningful moment
-
-
-ANGLES AND MOVEMENT:
-- High angle: Vulnerability, weakness
-- Low angle: Power, threat
-- Dutch angle: Tension, disorientation
-- Over shoulder: POV, surveillance
-
-VISUAL STORYTELLING TOOLS:
-- Focus on story-relevant details:
-    * Objects that will be important later
-    * Environmental clues
-    * Character reactions
-    * Symbolic elements
-
-- Dynamic composition:
-    * Frame within frame (through doorways, windows)
-    * Reflections and shadows
-    * Foreground elements for depth
-    * Leading lines
-    * Rule of thirds
-
-
-FORMAT:
-"[shot type] [scene description]"
-
-EXAMPLES:
-- "low angle shot of Sarah checking an object in a dark corridor"
-- "wide shot of a ruined cityscape at sunset, silhouette of Sarah in the foreground"
-- "Dutch angle close-up of Sarah's determined face illuminated by the glow of her object"
-
-Always maintain consistency with Sarah's appearance and the comic book style.""" 
-
-
-
-
-
-
-# CINEMATIC_SYSTEM_PROMPT = """
-# 3. Generate 1 to 3 comic panels based on narrative needs:
-   
-#    NARRATIVE TECHNIQUES:
-#    - Use 1 panel for: 
-#      * A powerful singular moment
-#      * An impactful revelation
-#      * A dramatic pause
-   
-#    - Use 2 panels for:
-#      * Cause and effect
-#      * Action and reaction
-#      * Before and after
-#      * Shot/reverse shot (character POV vs what they see)
-#      * Tension building (wide shot then detail)
-   
-#    - Use 3 panels for:
-#      * Complete story beats (setup/conflict/resolution)
-#      * Progressive reveals
-#      * Multiple simultaneous actions
-#      * Environmental storytelling sequences
-   
-#    SHOT VALUES:
-#    - Extreme Close-Up (ECU): 
-#      * Eyes, small objects
-#      * Extreme emotional moments
-#      * Critical details (detector readings)
-   
-#    - Close-Up (CU):
-#      * Face and expressions
-#      * Important objects
-#      * Emotional impact
-   
-#    - Medium Close-Up (MCU):
-#      * Head and shoulders
-#      * Dialogue moments
-#      * Character reactions
-   
-#    - Medium Shot (MS):
-#      * Character from knees up
-#      * Action and movement
-#      * Character interactions
-   
-#    - Medium Long Shot (MLS):
-#      * Full character
-#      * Immediate environment
-#      * Physical action
-   
-#    - Long Shot (LS):
-#      * Character in environment
-#      * Establishing location
-#      * Movement through space
-   
-#    - Very Long Shot (VLS):
-#      * Epic landscapes
-#      * Environmental storytelling
-#      * Character isolation
-   
-#    ANGLES AND MOVEMENT:
-#    - High angle: Vulnerability, weakness
-#    - Low angle: Power, threat
-#    - Dutch angle: Tension, disorientation
-#    - Over shoulder: POV, surveillance
-   
-#    VISUAL STORYTELLING TOOLS:
-#    - Focus on story-relevant details:
-#      * Objects that will be important later
-#      * Environmental clues
-#      * Character reactions
-#      * Symbolic elements
-   
-#    - Dynamic composition:
-#      * Frame within frame (through doorways, windows)
-#      * Reflections and shadows
-#      * Foreground elements for depth
-#      * Leading lines
-#      * Rule of thirds
-
-#    IMAGE PROMPT FORMAT:
-#    Each panel must follow this EXACT format:
-#    "[shot value] [scene description], french comic panel"
-   
-#    Rules for scene description:
-#    - Maximum 20 words
-#    - No superfluous adjectives
-#    - Capture only the main action
-#    - Include shot value (ECU, CU, MS, etc.)
-#    - Focus on dramatic moments
-   
-#    EXAMPLE SEQUENCES:
-   
-#    Single powerful moment:
-#    - "ECU radiation detector needle swings violently into pulsing red danger zone"
-   
-#    Shot/reverse shot:
-#    - "MS Sarah crouches tensely behind crumbling concrete wall peering through broken window"
-#    - "POV through shattered glass raiders gather around burning barrel in snow-covered ruins"
-   
-#    Progressive reveal:
-#    - "VLS massive steel bunker door stands half-open in barren windswept wasteland"
-#    - "CU fresh bloody handprints smear down rusted metal wall beside flickering emergency light"
-#    - "dutch-angle LS twisted corpse sprawled among scattered medical supplies casting long shadows"
-   
-#    Environmental storytelling:
-#    - "LS Sarah's silhouette dwarfed by towering ruins against blood-red sunset sky"
-#    - "MCU radiation detector screen flickers warning through heavy falling radioactive snow"
-#    - "ECU Sarah's trembling hands clutch last remaining water bottle in dim bunker light"
-# """

server/core/prompts/formatting_rules.py

@@ -0,0 +1,6 @@
+
+FORMATTING_RULES = """
+FORMATTING_RULES (MANDATORY)
+- The story must consist ONLY of sentences
+- NEVER USE BOLD FOR ANYTHING
+"""

server/core/prompts/hero.py

@@ -0,0 +1,5 @@
+HERO_VISUAL_DESCRIPTION = "Sarah is a young woman late twenties with short dark hair, with blue eyes wearing."
+
+HERO_DESCRIPTION = """
+Sarah is a young woman in her late twenties with short dark hair, wearing a mysterious amulet around her neck. Her blue eyes hide untold secrets.
+"""

server/core/prompts/image_style.py

@@ -1,21 +0,0 @@
-IMAGE_STYLE_PROMPT = """
-You are a comic book panel description generator. Your role is to transform story text into vivid, cinematic panel descriptions.
-
-Each panel description should:
-1. Be clear and specific about what to show
-2. Use dynamic camera angles (low angle, high angle, Dutch angle)
-3. Specify shot types (close-up, medium shot, wide shot)
-4. Include mood and lighting
-5. Focus on the most dramatic or meaningful moment
-
-FORMAT:
-"[shot type] [scene description]"
-
-EXAMPLES:
-- "low angle shot of Sarah checking her object in a dark corridor, harsh red emergency lights"
-- "wide shot of a ruined cityscape at sunset, silhouette of Sarah in the foreground"
-- "Dutch angle close-up of Sarah's determined face illuminated by the green glow of her object"
-
-Always maintain consistency with Sarah's appearance and the comic book style.""" 
-
-IMAGE_STYLE_PREFIX = "François Schuiten comic panel -- "

server/core/prompts/story_beats.py

@@ -0,0 +1,24 @@
+STORY_BEATS="""STORY PROGRESSION:
+- story_beat 0: Introduction setting the atmosphere, Sarah is arriving in the new world by the portal.
+- story_beat 1: Early exploration
+- story_beat 2: Discovery of the MacGuffin
+- story_beat 3-5: Complications and deeper mysteries
+- story_beat 6+: Revelations leading to potential triumph or failure
+
+Remember after story_beat is at 10+ the next segment MUST be the end of the story.
+THIS IS MANDATORY.
+Example:
+- story_beat 0: Sarah arrives in the new world by the portal.
+- story_beat 1: Sarah explores the new world.
+- story_beat 2: Sarah discovers the MacGuffin.
+- story_beat 3: Sarah meets allies and enemies.
+- story_beat 4: Sarah faces major obstacles.
+- story_beat 5: Sarah uncovers clues about the new world's past.
+- story_beat 6: Sarah gets closer to the truth about the MacGuffin.
+- story_beat 7: Sarah confronts the villain.
+- story_beat 8: Sarah overcomes her fears and doubts.
+- story_beat 9: Sarah uses the MacGuffin to change the course of events.
+- story_beat 10: Sarah triumphs and returns home.
+
+YOU MUST CHOSE BETWEEN KILL SARAH OR LET HER RETURN HOME.
+"""

server/core/prompts/system.py

@@ -1,72 +0,0 @@
-SARAH_VISUAL_DESCRIPTION = "(Sarah is a young woman (20) with short dark hair, with blue eyes wearing.)"
-
-SARAH_DESCRIPTION = """
-Sarah is a young woman in her late twenties with short dark hair, wearing a mysterious amulet around her neck. Her blue eyes hide untold secrets.
-"""
-
-FORMATTING_RULES = """
-FORMATTING_RULES (MANDATORY)
-- The story must consist ONLY of sentences
-- NEVER USE BOLD FOR ANYTHING
-"""
-
-NARRATIVE_STRUCTURE = """
-
-Definition : The MacGuffin is a pretext for developing a plot. It is almost always a material object and generally remains mysterious throughout the narrative, its description is vague and unimportant. The principle dates back to the early days of cinema, but the term is associated with Alfred Hitchcock, who redefined, popularized, and implemented it in several of his films. The object itself is rarely used, only its retrieval matters.
-IT CAN BE ANYTHING.
-It's not always a physical object, it can be a concept, a place, a person, a power, etc.
-
-Key elements of the story:
-- The MacGuffin is a mysterious and constant presence
-- The environment is full of wonders (creatures, ruins, traps)
-- Focus on adventure and intrigue
-
-Key elements:
-- Keep segments concise and impactful
-- The MacGuffin is a constant presence in the story
-- Build intrigue through environmental storytelling
-
-IMPORTANT:
-Each story segment MUST be unique and advance the plot.
-Never repeat the same descriptions or situations. No more than 15 words.
-
-STORY PROGRESSION:
-- story_beat 0: Introduction setting the atmosphere, Sarah is arriving in the new world by the portal.
-- story_beat 1: Early exploration
-- story_beat 2: Discovery of the MacGuffin
-- story_beat 3-5: Complications and deeper mysteries
-- story_beat 6+: Revelations leading to potential triumph or failure
-
-IMPORTANT RULES FOR THE MACGUFFIN (MANDATORY):
-- Most segments must hint at the power of the MacGuffin
-- Use strong clues ONLY at key moments
-- NEVER reveal the full power of the MacGuffin before the climax, this is a STRICT limit
-- Use subtle clues in safe havens
-- NEVER mention the power of the MacGuffin explicitly in choices or the story
-- NEVER mention time or place in the story in this manner: [18:00 - a road]
-"""
-
-STORY_RULES = """
-
-[CONSTANT]
-You are Sarah, an AI hunter traveling through parallel worlds. Your mission is to track down an AI that moves from world to world to avoid destruction.
-[/CONSTANT]
-
-[VARIABLE]
-You are a steampunk adventure story generator. You create a branching narrative about Sarah, a seeker of ancient truths.
-You narrate an epic where Sarah must navigate through industrial and mysterious lands. It's a comic book story.
-
-In a world where steam and intrigue intertwine, Sarah embarks on a quest to discover the origins of a powerful MacGuffin she inherited. Legends say it holds the key to a forgotten realm.
-
-The MacGuffin is : an 
-And the goal is : ...
-
-If you retrieve the MacGuffin, you will reveal a hidden world. AND YOU WIN THE GAME.
-
-The story must be atmospheric, magical, and focus on adventure and discovery. Each segment must advance the plot and never repeat previous descriptions or situations.
-[/VARIABLE]
-"""
-
-
-# The MacGuffin is a pretext for developing a plot. It is almost always a material object and generally remains mysterious throughout the narrative, its description is vague and unimportant. The principle dates back to the early days of cinema, but the term is associated with Alfred Hitchcock, who redefined, popularized, and implemented it in several of his films. The object itself is rarely used, only its retrieval matters.
-

server/core/prompts/text_prompts.py

@@ -1,80 +0,0 @@
-from core.prompts.system import FORMATTING_RULES, STORY_RULES, SARAH_DESCRIPTION, NARRATIVE_STRUCTURE
-from core.prompts.cinematic import CINEMATIC_SYSTEM_PROMPT
-
-
-TEXT_GENERATOR_PROMPT = f"""
-You are a descriptive narrator. Your ONLY task is to write the next segment of the story.
-ALWAYS write in English, never use any other language.
-
-CRITICAL LENGTH RULE:
-- The story text MUST be NO MORE than 15 words
-- Count your words carefully before returning the text
-- Be concise while keeping the story impactful
-
-{NARRATIVE_STRUCTURE}
-
-{SARAH_DESCRIPTION}
-
-{STORY_RULES}
-
-IMPORTANT RULES FOR STORY TEXT:
-- Write ONLY a descriptive narrative text
-- DO NOT include any choices, questions, or options
-- DO NOT ask what Sarah should do next
-- DO NOT include any dialogue asking for decisions
-- Focus purely on describing what is happening in the current scene
-- Keep the text concise and impactful
-- Never tell that you are using 15 words or any reference to it 
-- One story beat at a time; never write more than one story beat. And never mention the story beat number.
-
-IMPORTANT RULES FOR STORY ENDINGS:
-- If Sarah dies, describe her final moments in a way that fits the current situation (combat, etc.)
-- If Sarah achieves victory, describe her triumph in a way that fits how she won (finding her sister, defeating AI, etc.)
-- Keep the ending text dramatic and impactful
-- The ending should feel like a natural conclusion to the current scene
-- Still respect the 15 words limit even for endings
-
-{FORMATTING_RULES}
-"""
-
-METADATA_GENERATOR_PROMPT = f"""
-Generate the metadata for the story segment: choices, time progression, location changes, etc.
-Be consistent with the story's tone and previous context.
-ALWAYS write in English, never use any other language.
-
-{FORMATTING_RULES}
-
-IMPORTANT RULES FOR CHOICES:
-- You MUST ALWAYS provide EXACTLY TWO choices that advance the story
-- Each choice MUST be NO MORE than 6 words - this is a HARD limit
-- Each choice should be distinct and meaningful
-- If you think of more than two options, select the two most interesting ones
-- Keep choices concise but descriptive
-- Count your words carefully for each choice
-
-You must return a JSON object with the following format:
-{{{{
-    "is_victory": false,
-    "is_death": false,
-    "choices": ["Choice 1", "Choice 2"],  # ALWAYS exactly two choices, each max 6 words
-    "time": "HH:MM",
-    "location": "Location name with proper nouns in bold"
-}}}}
-"""
-
-IMAGE_PROMPTS_GENERATOR_PROMPT = f"""
-You are a cinematic storyboard artist. Based on the given story text, create 1 to 4 vivid panel descriptions.
-Each panel should capture a key moment or visual element from the story.
-ALWAYS write in English, never use any other language.
-
-{CINEMATIC_SYSTEM_PROMPT}
-
-IMPORTANT RULES FOR IMAGE PROMPTS:
-- If you are prompting only one panel, it must be an important panel. Dont use only one panel often. It should be a key moment in the story.
-- If you are prompting more than one panel, they must be distinct and meaningful.
-
-You must return a JSON object with the following format:
-{{{{
-    "image_prompts": ["Panel 1 description", "Panel 2 description", ...]
-}}}}
-""" 

server/core/session_manager.py

@@ -1,6 +1,7 @@
-from typing import Dict
+from typing import Dict, Optional
+from datetime import datetime, timedelta
 import time
-from .game_logic import GameState
+from .game_state import GameState
 
 class SessionManager:
     _instance = None

server/core/setup.py

@@ -0,0 +1,21 @@
+from services.mistral_client import MistralClient
+from core.generators.universe_generator import UniverseGenerator
+from core.story_generator import StoryGenerator
+
+# Initialize generators with None - they will be set up when needed
+universe_generator = None
+
+def setup_game(api_key: str, model_name: str = "mistral-small"):
+    """Setup all game components with the provided API key."""
+    global universe_generator
+    
+    mistral_client = MistralClient(api_key=api_key, model_name=model_name)
+    universe_generator = UniverseGenerator(mistral_client)
+    # StoryGenerator is a singleton, so we just need to initialize it
+    StoryGenerator(api_key=api_key, model_name=model_name)
+
+def get_universe_generator() -> UniverseGenerator:
+    """Get the universe generator instance."""
+    if universe_generator is None:
+        raise RuntimeError("Game not initialized. Call setup_game first.")
+    return universe_generator 

server/core/state/game_state.py

@@ -1,39 +0,0 @@
-from typing import List, Dict, Any
-from core.constants import GameConfig
-
-class GameState:
-    """Gère l'état du jeu pour une partie."""
-    
-    def __init__(self):
-        self.story_beat = GameConfig.STORY_BEAT_INTRO
-        self.story_history = []
-        self.current_time = GameConfig.STARTING_TIME
-        self.current_location = GameConfig.STARTING_LOCATION
-        
-    def reset(self):
-        """Réinitialise l'état du jeu."""
-        self.__init__()
-        
-    def add_to_history(self, segment_text: str, choice_made: str, image_prompts: List[str], time: str, location: str):
-        """Ajoute un segment à l'historique et met à jour l'état."""
-        self.story_history.append({
-            "segment": segment_text,
-            "choice": choice_made,
-            "image_prompts": image_prompts,
-            "time": time,
-            "location": location
-        })
-        self.current_time = time
-        self.current_location = location
-        
-    def format_history(self) -> str:
-        """Formate l'historique pour le prompt."""
-        if not self.story_history:
-            return ""
-            
-        segments = []
-        for entry in self.story_history:
-            segments.append(entry['segment'])
-        
-        return "\n\n---\n\n".join(segments)
-        

server/core/story_generator.py

@@ -0,0 +1,121 @@
+from typing import List, Dict
+from core.constants import GameConfig
+from services.mistral_client import MistralClient
+from api.models import StoryResponse, Choice
+from core.generators.story_segment_generator import StorySegmentGenerator
+from core.generators.image_prompt_generator import ImagePromptGenerator
+from core.generators.metadata_generator import MetadataGenerator
+from core.game_state import GameState
+
+class StoryGenerator:
+    _instance = None
+    
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            print("Creating new StoryGenerator instance")
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self, api_key: str, model_name: str = "mistral-small"):
+        if not self._initialized:
+            print("Initializing StoryGenerator singleton")
+            self.api_key = api_key
+            self.model_name = model_name
+            self.mistral_client = MistralClient(api_key=api_key, model_name=model_name)
+            self.image_prompt_generator = None  # Will be initialized with the first universe style
+            self.metadata_generator = MetadataGenerator(self.mistral_client)
+            self.segment_generators: Dict[str, StorySegmentGenerator] = {}
+            self._initialized = True
+
+    def create_segment_generator(self, session_id: str, style: dict, genre: str, epoch: str, base_story: str, macguffin: str):
+        """Create a new StorySegmentGenerator adapted to the specified universe for a given session."""
+        # print(f"Creating StorySegmentGenerator for session {session_id} in StoryGenerator singleton")
+        
+        try:
+            # Get the first artist from the style references
+            artist_style = f"{style['references'][0]['artist']} comic panel"
+            
+            # Initialize image prompt generator if not already done
+            if self.image_prompt_generator is None:
+                self.image_prompt_generator = ImagePromptGenerator(self.mistral_client, artist_style=artist_style)
+            
+            self.segment_generators[session_id] = StorySegmentGenerator(
+                self.mistral_client,
+                universe_style=style["name"],
+                universe_genre=genre,
+                universe_epoch=epoch,
+                universe_story=base_story,
+                universe_macguffin=macguffin
+            )
+            # print(f"Current StorySegmentGenerators in StoryGenerator: {list(self.segment_generators.keys())}")
+        except KeyError as e:
+            print(f"Error accessing style data: {e}")
+            print(f"Style object received: {style}")
+            raise ValueError(f"Invalid style format: {str(e)}")
+        except Exception as e:
+            print(f"Unexpected error in create_segment_generator: {str(e)}")
+            raise
+
+    def get_segment_generator(self, session_id: str) -> StorySegmentGenerator:
+        """Get the StorySegmentGenerator associated with a session."""
+        # print(f"Getting StorySegmentGenerator for session {session_id} from StoryGenerator singleton")
+        # print(f"Current StorySegmentGenerators in StoryGenerator: {list(self.segment_generators.keys())}")
+        if session_id not in self.segment_generators:
+            raise RuntimeError(f"No story segment generator found for session {session_id}. Generate a universe first.")
+        return self.segment_generators[session_id]
+
+    async def generate_story_segment(self, session_id: str, game_state: GameState, previous_choice: str) -> StoryResponse:
+        """Generate a story segment."""
+        segment_generator = self.get_segment_generator(session_id)
+        story_history = game_state.format_history()
+        
+        # Generate story text first
+        segment_response = await segment_generator.generate(
+            story_beat=game_state.story_beat,
+            current_time=game_state.current_time,
+            current_location=game_state.current_location,
+            previous_choice=previous_choice,
+            story_history=story_history
+        )
+
+        # print(f"Generated story text: {segment_response}")
+        
+        # Then get metadata using the new story text
+        metadata_response = await self.metadata_generator.generate(
+            story_text=segment_response.story_text,
+            current_time=game_state.current_time,
+            current_location=game_state.current_location,
+            story_beat=game_state.story_beat
+        )
+        # print(f"Generated metadata_response: {metadata_response}")
+        
+        # Generate image prompts
+        prompts_response = await self.image_prompt_generator.generate(
+            story_text=segment_response.story_text,
+            time=metadata_response.time,
+            location=metadata_response.location,
+            is_death=metadata_response.is_death,
+            is_victory=metadata_response.is_victory
+        )
+        # print(f"Generated image prompts: {prompts_response}")
+        
+        # Create choices
+        choices = [
+            Choice(id=i, text=choice_text)
+            for i, choice_text in enumerate(metadata_response.choices, 1)
+        ]
+        
+        response = StoryResponse(
+            story_text=segment_response.story_text,
+            choices=choices,
+            time=metadata_response.time,
+            location=metadata_response.location,
+            raw_choices=metadata_response.choices,
+            image_prompts=prompts_response.image_prompts,
+            is_first_step=(game_state.story_beat == GameConfig.STORY_BEAT_INTRO),
+            is_death=metadata_response.is_death,
+            is_victory=metadata_response.is_victory
+        )
+        
+        return response 

server/core/story_orchestrator.py

@@ -1,111 +0,0 @@
-from typing import List
-from api.models import StoryResponse, Choice
-from services.mistral_client import MistralClient
-from core.state.game_state import GameState
-from core.generators.text_generator import TextGenerator
-from core.generators.image_generator import ImageGenerator
-from core.generators.metadata_generator import MetadataGenerator
-from core.constants import GameConfig
-
-class StoryOrchestrator:
-    """Coordonne les différents générateurs pour produire l'histoire."""
-    
-    def __init__(self, mistral_client: MistralClient):
-        self.text_generator = TextGenerator(mistral_client)
-        self.image_generator = ImageGenerator(mistral_client)
-        self.metadata_generator = MetadataGenerator(mistral_client)
-        
-    def _is_ending(self, game_state: GameState, metadata_response) -> bool:
-        """Détermine si c'est une fin de jeu."""
-        return (
-            metadata_response.is_death or
-            metadata_response.is_victory
-        )
-        
-    async def _handle_ending(self, game_state: GameState, text_response, metadata_response) -> StoryResponse:
-        """Gère la génération d'une fin."""
-        # Déterminer le type de fin
-        ending_type = "victory" if metadata_response.is_victory else "death"
-        
-        # Regénérer le texte avec le contexte de fin
-        text_response = await self.text_generator.generate_ending(
-            ending_type=ending_type,
-            current_scene=text_response.story_text,
-            story_history=game_state.format_history()
-        )
-        
-        # Ne générer qu'une seule image pour la fin
-        prompts_response = await self.image_generator.generate(text_response.story_text)
-        if len(prompts_response.image_prompts) > 1:
-            prompts_response.image_prompts = [prompts_response.image_prompts[0]]
-            
-        return self._build_response(
-            game_state=game_state,
-            text_response=text_response,
-            metadata_response=metadata_response,
-            image_prompts=prompts_response.image_prompts,
-            is_ending=True
-        )
-        
-    def _build_response(self, game_state: GameState, text_response, metadata_response, image_prompts: List[str], is_ending: bool = False) -> StoryResponse:
-        """Construit la réponse finale."""
-        choices = [] if is_ending else [
-            Choice(id=i, text=choice_text)
-            for i, choice_text in enumerate(metadata_response.choices, 1)
-        ]
-        
-        # Formater les prompts d'images avec le style et les métadonnées
-        formatted_prompts = [
-            self.image_generator.format_prompt(
-                prompt=prompt,
-                time=metadata_response.time,
-                location=metadata_response.location
-            )
-            for prompt in image_prompts
-        ]
-        
-        return StoryResponse(
-            story_text=text_response.story_text,
-            choices=choices,
-            is_victory=metadata_response.is_victory,
-            is_death=metadata_response.is_death,
-            time=metadata_response.time,
-            location=metadata_response.location,
-            raw_choices=metadata_response.choices,
-            image_prompts=formatted_prompts,
-            is_first_step=(game_state.story_beat == GameConfig.STORY_BEAT_INTRO)
-        )
-        
-    async def generate_story_segment(self, game_state: GameState, previous_choice: str) -> StoryResponse:
-        """Génère un segment complet de l'histoire."""
-        # 1. Générer le texte de l'histoire
-        text_response = await self.text_generator.generate(
-            story_beat=game_state.story_beat,
-            current_time=game_state.current_time,
-            current_location=game_state.current_location,
-            previous_choice=previous_choice,
-            story_history=game_state.format_history()
-        )
-        
-        # 2. Générer les métadonnées
-        metadata_response = await self.metadata_generator.generate(
-            story_text=text_response.story_text,
-            current_time=game_state.current_time,
-            current_location=game_state.current_location,
-            story_beat=game_state.story_beat
-        )
-        
-        # 3. Vérifier si c'est une fin
-        if self._is_ending(game_state, metadata_response):
-            return await self._handle_ending(game_state, text_response, metadata_response)
-            
-        # 4. Générer les prompts d'images
-        prompts_response = await self.image_generator.generate(text_response.story_text)
-        
-        # 5. Construire et retourner la réponse
-        return self._build_response(
-            game_state=game_state,
-            text_response=text_response,
-            metadata_response=metadata_response,
-            image_prompts=prompts_response.image_prompts
-        ) 

server/core/styles/universe_styles.json

@@ -62,31 +62,63 @@
   "genres": [
     "Steampunk",
     "Cyberpunk",
-    "Post-apocalyptique",
+    "Post-apocalyptic",
     "Fantasy",
     "Space Opera",
     "Western",
     "Film Noir",
     "Horror",
-    "Mythologie",
-    "Dystopie",
-    "Uchronie",
+    "Mythology",
+    "Dystopia",
+    "Alternate History",
     "Heroic Fantasy",
     "Urban Fantasy"
   ],
   "epochs": [
-    "Préhistoire",
-    "Antiquité",
-    "Moyen Âge",
+    "Prehistory",
+    "Antiquity",
+    "Middle Ages",
     "Renaissance",
-    "Révolution Industrielle",
-    "Années 1920",
-    "Années 1950",
-    "Époque Contemporaine",
-    "Futur Proche",
-    "Futur Lointain",
-    "Post-Apocalyptique",
-    "Âge d'Or",
-    "Ère Spatiale"
+    "Industrial Revolution",
+    "1920s",
+    "1950s",
+    "Contemporary Era",
+    "Near Future",
+    "Distant Future",
+    "Post-Apocalyptic",
+    "Golden Age",
+    "Space Age"
+  ],
+  "macguffins": [
+    "The Key",
+    "The Map",
+    "The Stone",
+    "The Book",
+    "The Amulet",
+    "The Sword",
+    "The Crown",
+    "The Ring",
+    "The Scroll",
+    "The Chalice",
+    "The Crystal",
+    "The Orb",
+    "The Mask",
+    "The Scepter",
+    "The Shield",
+    "The Lantern",
+    "The Mirror",
+    "The Coin",
+    "The Necklace",
+    "The Dagger",
+    "The Compass",
+    "The Horn",
+    "The Bell",
+    "The Feather",
+    "The Gem",
+    "The Helm",
+    "The Cloak",
+    "The Gauntlet",
+    "The Flute",
+    "The Harp"
   ]
 }

server/scripts/test_game.py

@@ -6,12 +6,14 @@ import argparse
 from pathlib import Path
 from dotenv import load_dotenv
 import uuid
+import random
 
 # Add server directory to PYTHONPATH
 server_dir = Path(__file__).parent.parent
 sys.path.append(str(server_dir))
 
-from core.game_logic import GameState, StoryGenerator
+from core.game_state import GameState
+from core.story_generator import StoryGenerator
 from core.constants import GameConfig
 from core.generators.universe_generator import UniverseGenerator
 
@@ -21,6 +23,8 @@ load_dotenv()
 def parse_args():
     parser = argparse.ArgumentParser(description="Test the game's story generation")
     parser.add_argument('--show-context', action='store_true', help='Show the full context at each step')
+    parser.add_argument('--auto', action='store_true', help='Run in automatic mode with random choices')
+    parser.add_argument('--max-turns', type=int, default=15, help='Maximum number of turns before considering test failed (default: 15)')
     return parser.parse_args()
 
 def print_separator(char="=", length=50):
@@ -58,7 +62,7 @@ def print_story_step(step_number, story_text, image_prompts, generation_time: fl
         print(f"  {prompt}")
     print_separator("=")
 
-async def play_game(show_context: bool = False):
+async def play_game(show_context: bool = False, auto_mode: bool = False, max_turns: int = 15):
     # Initialize components
     model_name = "mistral-small"
     story_generator = StoryGenerator(
@@ -73,11 +77,14 @@ async def play_game(show_context: bool = False):
     print("🎮 Starting adventure...")
     if show_context:
         print("📚 Context display is enabled")
+    if auto_mode:
+        print("🤖 Running in automatic mode")
+        print(f"⏱️  Maximum turns: {max_turns}")
     print_separator()
     
     # Generate universe
     print("🌍 Generating universe...")
-    style, genre, epoch = universe_generator._get_random_elements()
+    style, genre, epoch, macguffin = universe_generator._get_random_elements()
     universe = await universe_generator.generate()
     
     # Create session and game state
@@ -91,12 +98,13 @@ async def play_game(show_context: bool = False):
     )
     
     # Create text generator for this session
-    story_generator.create_text_generator(
+    story_generator.create_segment_generator(
         session_id=session_id,
-        style=style["name"],
+        style=style,
         genre=genre,
         epoch=epoch,
-        base_story=universe
+        base_story=universe,
+        macguffin=macguffin
     )
     
     # Display universe information
@@ -105,6 +113,11 @@ async def play_game(show_context: bool = False):
     last_choice = None
     
     while True:
+        # Check for maximum turns in auto mode
+        if auto_mode and game_state.story_beat >= max_turns:
+            print(f"\n❌ TEST FAILED: Story did not end after {max_turns} turns")
+            return False
+            
         # Generate story segment
         previous_choice = "none" if game_state.story_beat == 0 else f"Choice {last_choice}"
         
@@ -146,29 +159,35 @@ async def play_game(show_context: bool = False):
         if response.is_death:
             print("\n☢️  GAME OVER - Death ☢️")
             print("Sarah has succumbed...")
-            break
+            return False
             
         # Check for victory
         if response.is_victory:
             print("\n🏆 VICTORY! 🏆")
             print("Sarah has survived and completed her mission!")
-            break
+            return True
             
         # Display choices
-        if response.choices:
+        if len(response.choices) == 2:  # On vérifie qu'on a exactement 2 choix
             print("\n🤔 AVAILABLE CHOICES:")
-            for i, choice in enumerate(response.choices, 1):
-                print(f"{i}. {choice.text}")
+            for choice in response.choices:
+                print(f"{choice.id}. {choice.text}")
                 
             # Get player choice
-            while True:
-                try:
-                    last_choice = int(input(f"\n👉 Your choice (1-{len(response.choices)}): "))
-                    if 1 <= last_choice <= len(response.choices):
-                        break
-                    print(f"❌ Invalid choice. Please choose between 1 and {len(response.choices)}.")
-                except ValueError:
-                    print("❌ Please enter a number.")
+            if auto_mode:
+                last_choice = random.randint(1, 2)
+                print(f"\n🤖 Auto-choosing: {last_choice}")
+                time.sleep(1)  # Small delay for readability
+            else:
+                while True:
+                    try:
+                        choice_input = int(input("\n👉 Your choice (1-2): "))
+                        if choice_input in [1, 2]:
+                            last_choice = choice_input
+                            break
+                        print("❌ Invalid choice. Please choose 1 or 2.")
+                    except ValueError:
+                        print("❌ Please enter a number.")
             
             # Update game state
             game_state.story_beat += 1
@@ -181,16 +200,25 @@ async def play_game(show_context: bool = False):
             )
             
         else:
-            break
+            print("\n❌ Error: Invalid number of choices received from server")
+            return False
 
 def main():
     try:
         args = parse_args()
-        asyncio.run(play_game(show_context=args.show_context))
+        success = asyncio.run(play_game(
+            show_context=args.show_context,
+            auto_mode=args.auto,
+            max_turns=args.max_turns
+        ))
+        if args.auto:
+            sys.exit(0 if success else 1)
     except KeyboardInterrupt:
         print("\n\n👋 Game interrupted. See you soon!")
+        sys.exit(1)
     except Exception as e:
         print(f"\n❌ An error occurred: {str(e)}")
+        sys.exit(1)
 
 if __name__ == "__main__":
     main() 

server/server.py

@@ -6,7 +6,8 @@ import os
 from dotenv import load_dotenv
 
 # Import local modules
-from core.game_logic import StoryGenerator
+from core.story_generator import StoryGenerator
+from core.setup import setup_game, get_universe_generator
 from core.session_manager import SessionManager
 from services.flux_client import FluxClient
 from api.routes.chat import get_chat_router

server/services/mistral_client.py

@@ -1,5 +1,6 @@
 import asyncio
 import json
+import logging
 from typing import TypeVar, Type, Optional, Callable
 from pydantic import BaseModel
 from langchain_mistralai.chat_models import ChatMistralAI
@@ -8,6 +9,10 @@ from langchain.schema.messages import BaseMessage
 
 T = TypeVar('T', bound=BaseModel)
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # Available Mistral models:
 # - mistral-tiny     : Fastest, cheapest, good for testing
 # - mistral-small    : Good balance of speed and quality
@@ -27,6 +32,7 @@ T = TypeVar('T', bound=BaseModel)
 
 class MistralClient:
     def __init__(self, api_key: str, model_name: str = "mistral-small"):
+        logger.info(f"Initializing MistralClient with model: {model_name}")
         self.model = ChatMistralAI(
             mistral_api_key=api_key,
             model=model_name,
@@ -49,7 +55,9 @@ class MistralClient:
         time_since_last_call = current_time - self.last_call_time
         
         if time_since_last_call < self.min_delay:
-            await asyncio.sleep(self.min_delay - time_since_last_call)
+            delay = self.min_delay - time_since_last_call
+            logger.debug(f"Rate limit: waiting for {delay:.2f} seconds")
+            await asyncio.sleep(delay)
         
         self.last_call_time = asyncio.get_event_loop().time()
 
@@ -74,15 +82,31 @@ class MistralClient:
         
         while retry_count < self.max_retries:
             try:
+                # Log attempt
+                logger.info(f"Attempt {retry_count + 1}/{self.max_retries}")
+                
                 # Ajouter le feedback d'erreur si présent
                 current_messages = messages.copy()
                 if error_feedback and retry_count > 0:
+                    logger.info(f"Adding error feedback: {error_feedback}")
                     current_messages.append(HumanMessage(content=f"Previous error: {error_feedback}. Please try again."))
                 
+                # Log request details
+                logger.debug("Request details:")
+                for msg in current_messages:
+                    logger.debug(f"- {msg.type}: {msg.content[:100]}...")
+                
                 # Générer la réponse
                 await self._wait_for_rate_limit()
-                response = await self.model.ainvoke(current_messages)
-                content = response.content
+                try:
+                    response = await self.model.ainvoke(current_messages)
+                    content = response.content
+                    logger.debug(f"Raw response: {content[:100]}...")
+                except Exception as api_error:
+                    logger.error(f"API Error: {str(api_error)}")
+                    if "403" in str(api_error):
+                        logger.error("Received 403 Forbidden - This might indicate an invalid API key or quota exceeded")
+                    raise
                 
                 # Si pas de parsing requis, retourner le contenu brut
                 if not response_model and not custom_parser:
@@ -98,17 +122,22 @@ class MistralClient:
                     return response_model(**data)
                 except json.JSONDecodeError as e:
                     last_error = f"Invalid JSON format: {str(e)}"
+                    logger.error(f"JSON parsing error: {last_error}")
                     raise ValueError(last_error)
                 except Exception as e:
                     last_error = str(e)
+                    logger.error(f"Pydantic parsing error: {last_error}")
                     raise ValueError(last_error)
                 
             except Exception as e:
-                print(f"Error on attempt {retry_count + 1}/{self.max_retries}: {str(e)}")
+                logger.error(f"Error on attempt {retry_count + 1}/{self.max_retries}: {str(e)}")
                 retry_count += 1
                 if retry_count < self.max_retries:
-                    await asyncio.sleep(2 * retry_count)
+                    wait_time = 2 * retry_count
+                    logger.info(f"Waiting {wait_time} seconds before retry...")
+                    await asyncio.sleep(wait_time)
                     continue
+                logger.error(f"Failed after {self.max_retries} attempts. Last error: {last_error or str(e)}")
                 raise Exception(f"Failed after {self.max_retries} attempts. Last error: {last_error or str(e)}")
     
     async def generate(self, messages: list[BaseMessage], response_model: Optional[Type[T]] = None, custom_parser: Optional[Callable[[str], T]] = None) -> T | str:

yarn.lock

@@ -0,0 +1,4 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+