Delete app

app/agent.py

@@ -1,985 +0,0 @@
-"""
-LangGraph Agent for Vibe Reader
-Implements the agentic workflow for book recommendation based on visual vibes
-"""
-
-import os
-import json
-from typing import TypedDict, List, Dict, Any, Literal, Annotated
-from operator import add
-from openai import OpenAI
-from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
-from langgraph.graph import StateGraph, END
-from langgraph.types import interrupt
-from dotenv import load_dotenv
-
-load_dotenv()
-
-# ============================================================================
-# CONFIGURATION
-# ============================================================================
-
-NEBIUS_API_KEY = os.getenv("NEBIUS_API_KEY")
-NEBIUS_BASE_URL = "https://api.tokenfactory.nebius.com/v1/"
-VLM_MODEL = "google/gemma-3-27b-it-fast"
-REASONING_MODEL = "Qwen/Qwen3-30B-A3B-Thinking-2507"
-FAST_MODEL = "moonshotai/Kimi-K2-Instruct"  # Non-thinking model for simple tasks
-
-MODAL_VECTOR_STORE_URL = os.getenv("MODAL_VECTOR_STORE_URL", "https://placeholder-modal-url.modal.run/search")
-GOOGLE_BOOKS_MCP_URL = os.getenv("GOOGLE_BOOKS_MCP_URL", "https://mcp-1st-birthday-google-books-mcp.hf.space")
-
-NUM_BOOKS_TO_RETRIEVE = 10  # Target number of books with valid descriptions
-NUM_BOOKS_TO_FETCH = 15    # Fetch extra to account for books without descriptions
-NUM_FINAL_BOOKS = 3
-
-# ============================================================================
-# STATE DEFINITION
-# ============================================================================
-
-class AgentState(TypedDict):
-    """State maintained throughout the agent workflow"""
-    # User inputs
-    images: List[str]  # List of image URLs or base64 encoded images
-
-    # Conversation history (no reducer - we manage the list directly)
-    messages: List[Dict[str, str]]
-
-    # Vibe components (from JSON extraction)
-    aesthetic_genre_keywords: List[str]  # Genre/aesthetic keywords
-    mood_atmosphere: List[str]  # Mood descriptors
-    core_themes: List[str]  # Core themes
-    tropes: List[str]  # Story tropes
-    feels_like: str  # User-facing "feels like" description (what gets refined)
-    vibe_refinement_count: int  # Number of refinement iterations
-
-    # Book retrieval
-    retrieved_books: List[Dict[str, str]]  # List of {title, author} dicts
-    books_with_metadata: List[Dict[str, Any]]  # Enriched with Google Books data
-
-    # Narrowing process
-    q1_question: str  # First narrowing question (stored for resume)
-    q2_question: str  # Second narrowing question (stored for resume)
-    user_preferences: Dict[str, Any]  # Accumulated user preferences from Q&A (question + answer pairs)
-    final_books: List[Dict[str, Any]]  # Final 3 books
-
-    # Final outputs
-    soundtrack_url: str  # ElevenLabs generated soundtrack
-
-    # Debug/reasoning (no reducer - we manage the list directly)
-    reasoning: List[str]
-
-
-# ============================================================================
-# HELPER FUNCTIONS
-# ============================================================================
-
-def create_openai_client() -> OpenAI:
-    """Create OpenAI client configured for Nebius"""
-    return OpenAI(api_key=NEBIUS_API_KEY, base_url=NEBIUS_BASE_URL)
-
-
-def call_llm(messages: List[Dict[str, Any]], temperature: float = 0.7, model: str = REASONING_MODEL, include_reasoning: bool = False, max_tokens: int = 2500):
-    """Generic LLM call for reasoning and decision-making using Nebius API
-
-    Args:
-        messages: Conversation messages
-        temperature: Sampling temperature
-        model: Model to use
-        include_reasoning: If True, returns tuple of (content, reasoning_text)
-        max_tokens: Maximum tokens for response (default 1000)
-
-    Returns:
-        str or tuple: Response content, or (content, reasoning) if include_reasoning=True
-    """
-    client = create_openai_client()  # Uses Nebius
-    response = client.chat.completions.create(
-        model=model,
-        messages=messages,
-        temperature=temperature,
-        max_tokens=max_tokens
-    )
-
-    message = response.choices[0].message
-    content = message.content or ""
-
-    if include_reasoning:
-        # Nebius API returns reasoning in a separate field for Thinking models
-        reasoning = getattr(message, 'reasoning_content', None) or ""
-        
-        if reasoning:
-            # If content is empty, log a warning but don't try to extract from reasoning
-            # (the last line of reasoning is usually garbage, not the answer)
-            if not content.strip():
-                print(f"[DEBUG AGENT] Warning: LLM returned empty content with reasoning. This may indicate an issue.")
-            return content, reasoning
-        
-        # Fallback: try parsing <think>...</think> tags from content
-        import re
-        think_match = re.match(r'<think>(.*?)</think>(.*)', content, re.DOTALL)
-        if think_match:
-            reasoning = think_match.group(1).strip()
-            final_content = think_match.group(2).strip()
-            return final_content, reasoning
-        
-        # No reasoning found
-        return content, "No reasoning trace found"
-
-    return content
-
-
-# ============================================================================
-# NODES
-# ============================================================================
-
-def generate_initial_vibe(state: AgentState) -> AgentState:
-    """Node: Generate initial vibe description from uploaded images using VLM"""
-    from prompts import VIBE_EXTRACTION
-    from utils import parse_json_response, extract_vibe_components
-
-    client = create_openai_client()
-
-    # Construct message with images
-    content = [{"type": "text", "text": "Analyze these images and extract the vibe:"}]
-    for img in state["images"]:
-        # Convert local file paths to base64 data URLs if needed
-        if img.startswith(('http://', 'https://', 'data:')):
-            # Already a valid URL
-            image_url = img
-        else:
-            # Local file path - convert to base64
-            import base64
-            from pathlib import Path
-
-            img_path = Path(img)
-            if img_path.exists():
-                with open(img_path, 'rb') as f:
-                    img_data = base64.b64encode(f.read()).decode('utf-8')
-                # Determine MIME type from extension
-                ext = img_path.suffix.lower()
-                mime_types = {'.jpg': 'jpeg', '.jpeg': 'jpeg', '.png': 'png', '.gif': 'gif', '.webp': 'webp'}
-                mime = mime_types.get(ext, 'jpeg')
-                image_url = f"data:image/{mime};base64,{img_data}"
-            else:
-                state["reasoning"].append(f"⚠️ Warning: Image file not found: {img}")
-                continue
-
-        content.append({
-            "type": "image_url",
-            "image_url": {"url": image_url}
-        })
-
-    response = client.chat.completions.create(
-        model=VLM_MODEL,
-        messages=[
-            {"role": "system", "content": VIBE_EXTRACTION},
-            {"role": "user", "content": content}
-        ],
-        temperature=0.7,
-        max_tokens=2000
-    )
-
-    vibe_json_str = response.choices[0].message.content
-
-    # Parse JSON response
-    vibe_json = parse_json_response(vibe_json_str)
-    if not vibe_json:
-        state["reasoning"].append(f"❌ Failed to parse vibe JSON. Raw response: {vibe_json_str[:200]}")
-        # Fallback to simple extraction
-        state["feels_like"] = vibe_json_str
-        state["aesthetic_genre_keywords"] = []
-        state["mood_atmosphere"] = []
-        state["core_themes"] = []
-        state["tropes"] = []
-    else:
-        # Extract components
-        components = extract_vibe_components(vibe_json)
-        state["aesthetic_genre_keywords"] = components["aesthetic_genre_keywords"]
-        state["mood_atmosphere"] = components["mood_atmosphere"]
-        state["core_themes"] = components["core_themes"]
-        state["tropes"] = components["tropes"]
-        state["feels_like"] = components["feels_like"]
-
-        state["reasoning"].append(f"✅ Extracted vibe components:\n"
-                                 f"  - Aesthetics: {', '.join(state['aesthetic_genre_keywords'])}\n"
-                                 f"  - Mood: {', '.join(state['mood_atmosphere'])}\n"
-                                 f"  - Themes: {', '.join(state['core_themes'])}\n"
-                                 f"  - Tropes: {', '.join(state['tropes'])}")
-
-    state["vibe_refinement_count"] = 0
-
-    # Only show feels_like to user
-    assistant_message = f"Here's the vibe I'm getting from your images:\n\n{state['feels_like']}\n\nDoes this capture what you're looking for, or would you like me to adjust it?"
-    state["messages"].append({
-        "role": "assistant",
-        "content": assistant_message
-    })
-
-    # Wait for user feedback; when resumed, user_response will contain their reply
-    user_response = interrupt(assistant_message)
-    if user_response:
-        state["messages"].append({"role": "user", "content": user_response})
-
-    return state
-
-
-def refine_vibe(state: AgentState) -> AgentState:
-    """Node: Refine vibe based on user feedback - only refines feels_like portion"""
-    from prompts import VIBE_REFINEMENT
-    from utils import strip_thinking_tags
-
-    print("[DEBUG AGENT] refine_vibe node started")
-    
-    # Get the latest user message (feedback)
-    user_messages = [m for m in state["messages"] if m.get("role") == "user"]
-    print(f"[DEBUG AGENT] Found {len(user_messages)} user messages")
-    if not user_messages:
-        state["reasoning"].append("⚠️ No user feedback found for refinement; skipping refine_vibe step")
-        return state
-
-    user_feedback = user_messages[-1]["content"]
-    print(f"[DEBUG AGENT] user_feedback: {user_feedback[:50] if user_feedback else 'None'}...")
-
-    # Use LLM to refine only the feels_like description
-    # Keep other vibe components (aesthetics, themes, tropes) unchanged
-    messages = [
-        {"role": "system", "content": VIBE_REFINEMENT},
-        {"role": "user", "content": f"Current 'feels like' description: {state['feels_like']}\n\nUser feedback: {user_feedback}\n\nProvide the refined 'feels like' description (4-5 sentences):"}
-    ]
-
-    print(f"[DEBUG AGENT] Calling LLM for refinement...")
-    refined_feels_like, reasoning = call_llm(messages, temperature=0.7, include_reasoning=True)
-    print(f"[DEBUG AGENT] LLM returned content: {refined_feels_like[:200] if refined_feels_like else 'None'}...")
-    print(f"[DEBUG AGENT] LLM reasoning: {reasoning[:200] if reasoning else 'None'}...")
-
-    # Ensure no thinking tags leak into the feels_like
-    refined_feels_like = strip_thinking_tags(refined_feels_like)
-
-    # Update only the feels_like portion
-    state["feels_like"] = refined_feels_like
-    state["vibe_refinement_count"] += 1
-
-    assistant_message = f"I've refined the vibe:\n\n{refined_feels_like}\n\nIs this better, or would you like further adjustments?"
-    print(f"[DEBUG AGENT] Adding assistant message to state, current msg count: {len(state['messages'])}")
-    state["messages"].append({
-        "role": "assistant",
-        "content": assistant_message
-    })
-    state["reasoning"].append(f"🧠 REASONING (Vibe Refinement #{state['vibe_refinement_count']}):\n{reasoning}\n")
-    print(f"[DEBUG AGENT] After append, msg count: {len(state['messages'])}")
-
-    # Wait for user feedback on the refined vibe
-    print(f"[DEBUG AGENT] About to call interrupt()")
-    user_response = interrupt(assistant_message)
-    print(f"[DEBUG AGENT] interrupt() returned: {user_response}")
-    if user_response:
-        state["messages"].append({"role": "user", "content": user_response})
-
-    return state
-
-
-def check_vibe_satisfaction(state: AgentState) -> Literal["refine", "retrieve"]:
-    """Conditional edge: Check if user is satisfied with vibe description"""
-    from prompts import VIBE_SATISFACTION_CHECKER
-
-    # Get the last user message
-    user_messages = [m for m in state["messages"] if m.get("role") == "user"]
-    if not user_messages:
-        # No explicit feedback; default to moving forward
-        return "retrieve"
-
-    raw_content = user_messages[-1]["content"]
-
-    # Content may occasionally be a non-string (e.g., list from upstream tools);
-    # normalize to text before passing into the LLM.
-    if isinstance(raw_content, str):
-        last_user_msg = raw_content
-    elif isinstance(raw_content, list):
-        # Join any text-like chunks into a single string representation
-        last_user_msg = " ".join(str(x) for x in raw_content)
-    else:
-        last_user_msg = str(raw_content)
-
-    # Use LLM to determine satisfaction
-    messages = [
-        {"role": "system", "content": VIBE_SATISFACTION_CHECKER},
-        {"role": "user", "content": f"User's response: {last_user_msg}"}
-    ]
-
-    decision, reasoning = call_llm(messages, temperature=0.0, include_reasoning=True)
-    decision = decision.strip().lower() if decision else ""
-    
-    print(f"[DEBUG] check_vibe_satisfaction - user said: '{last_user_msg}'")
-    print(f"[DEBUG] check_vibe_satisfaction - LLM decision: '{decision}'")
-
-    state["reasoning"].append(f"🧠 REASONING (Satisfaction Check):\n{reasoning}\n\n→ Decision: {decision}")
-
-    if "satisfied" in decision and "not_satisfied" not in decision:
-        print(f"[DEBUG] check_vibe_satisfaction -> RETRIEVE (user satisfied)")
-        return "retrieve"
-    else:
-        print(f"[DEBUG] check_vibe_satisfaction -> REFINE (user not satisfied)")
-        return "refine"
-
-
-def retrieve_books(state: AgentState) -> AgentState:
-    """Node: Retrieve books from Modal vector store"""
-    import requests
-
-    # Construct full vibe query from all components
-    vibe_query = f"{state['feels_like']}\n\nGenres/Aesthetics: {', '.join(state['aesthetic_genre_keywords'])}\nMood: {', '.join(state['mood_atmosphere'])}\nThemes: {', '.join(state['core_themes'])}\nTropes: {', '.join(state['tropes'])}"
-
-    try:
-        # Call Modal vector store endpoint
-        print(f"DEBUG: Calling Modal URL: {MODAL_VECTOR_STORE_URL}")
-        state["reasoning"].append(f"📚 Calling Modal vector store with full vibe profile")
-        state["reasoning"].append(f"URL: {MODAL_VECTOR_STORE_URL}")
-
-        response = requests.post(
-            MODAL_VECTOR_STORE_URL,
-            json={
-                "query": vibe_query,
-                "top_k": NUM_BOOKS_TO_RETRIEVE,
-                "min_books_per_vibe": 1
-            },
-            timeout=180  # Long timeout for cold start
-        )
-        
-        print(f"DEBUG: Response status: {response.status_code}")
-        print(f"DEBUG: Response text: {response.text[:500] if response.text else 'empty'}")
-
-        if response.status_code == 200:
-            data = response.json()
-
-            # Extract books from search results with diversity across vibes
-            # Modal returns: {"results": [{"books": [...], "vibe_data": {...}, "score": ...}], ...}
-            # Strategy: Take up to MAX_BOOKS_PER_VIBE from each vibe to ensure diversity
-            MAX_BOOKS_PER_VIBE = 5
-            
-            books = []
-            seen = set()  # Track seen books for deduplication
-            
-            for result in data.get("results", []):
-                vibe_score = result.get("score", 0)
-                vibe_books = result.get("books", [])
-                books_from_this_vibe = 0
-                
-                for book in vibe_books:
-                    if books_from_this_vibe >= MAX_BOOKS_PER_VIBE:
-                        break
-                    
-                    title = book.get("title", "")
-                    author = book.get("author", "")
-                    key = (title.lower(), author.lower())
-                    
-                    # Skip duplicates
-                    if key in seen:
-                        continue
-                    
-                    seen.add(key)
-                    books.append({
-                        "title": title,
-                        "author": author,
-                        "vibe_score": vibe_score  # Track which vibe it came from
-                    })
-                    books_from_this_vibe += 1
-
-            # Fetch extra books to account for filtering (books without descriptions)
-            books = books[:NUM_BOOKS_TO_FETCH]
-
-            state["reasoning"].append(f"Retrieved {len(books)} books from {len(data.get('results', []))} vibes (max {MAX_BOOKS_PER_VIBE} per vibe)")
-
-        else:
-            raise Exception(f"HTTP {response.status_code}: {response.text[:200]}")
-
-    except Exception as e:
-        # Fallback to mock data for development
-        print(f"DEBUG ERROR: Vector store call failed: {e}")
-        import traceback
-        traceback.print_exc()
-        state["reasoning"].append(f"Vector store call failed: {e}. Using mock data.")
-        books = [
-            {"title": "The Night Circus", "author": "Erin Morgenstern"},
-            {"title": "The Ocean at the End of the Lane", "author": "Neil Gaiman"},
-            {"title": "The Starless Sea", "author": "Erin Morgenstern"},
-            {"title": "Piranesi", "author": "Susanna Clarke"},
-            {"title": "The House in the Cerulean Sea", "author": "TJ Klune"},
-            {"title": "Howl's Moving Castle", "author": "Diana Wynne Jones"},
-            {"title": "Circe", "author": "Madeline Miller"},
-            {"title": "The Invisible Life of Addie LaRue", "author": "V.E. Schwab"},
-            {"title": "Mexican Gothic", "author": "Silvia Moreno-Garcia"},
-            {"title": "The Ten Thousand Doors of January", "author": "Alix E. Harrow"},
-            {"title": "The Goblin Emperor", "author": "Katherine Addison"},
-            {"title": "The Priory of the Orange Tree", "author": "Samantha Shannon"},
-            {"title": "Uprooted", "author": "Naomi Novik"},
-            {"title": "The Bear and the Nightingale", "author": "Katherine Arden"},
-            {"title": "The City of Brass", "author": "S.A. Chakraborty"}
-        ]
-
-    state["retrieved_books"] = books
-    state["reasoning"].append(f"Total books in state: {len(books)}")
-
-    return state
-
-
-def call_google_books_mcp(title: str, author: str = "") -> Dict[str, Any]:
-    """
-    Call the Google Books MCP server via Gradio MCP endpoint.
-    
-    Args:
-        title: Book title
-        author: Book author (optional)
-    
-    Returns:
-        Book metadata dict or None if not found
-    """
-    import requests
-    
-    try:
-        # Gradio MCP endpoint (Streamable HTTP transport)
-        mcp_url = f"{GOOGLE_BOOKS_MCP_URL}/gradio_api/mcp/"
-        
-        # MCP uses JSON-RPC style calls
-        payload = {
-            "jsonrpc": "2.0",
-            "method": "tools/call",
-            "params": {
-                "name": "google_books_mcp_search_book_by_title_author",
-                "arguments": {
-                    "title": title,
-                    "author": author
-                }
-            },
-            "id": 1
-        }
-        
-        response = requests.post(
-            mcp_url,
-            json=payload,
-            headers={
-                "Content-Type": "application/json",
-                "Accept": "application/json, text/event-stream"
-            },
-            timeout=30
-        )
-        
-        if response.status_code != 200:
-            print(f"[DEBUG] Google Books MCP failed: {response.status_code} - {response.text[:200]}")
-            return None
-        
-        # Parse SSE response
-        for line in response.text.split('\n'):
-            if line.startswith('data: '):
-                try:
-                    data = json.loads(line[6:])
-                    if "result" in data:
-                        result = data["result"]
-                        if isinstance(result, dict):
-                            # Check if it's a direct book response
-                            if "success" in result and "book" in result:
-                                if result.get("success") and result.get("book"):
-                                    return result["book"]
-                            # Check if it's a content array response
-                            elif "content" in result:
-                                for content_item in result["content"]:
-                                    if content_item.get("type") == "text":
-                                        text_content = content_item.get("text", "")
-                                        if text_content.strip():
-                                            try:
-                                                book_data = json.loads(text_content)
-                                                if book_data.get("success") and book_data.get("found"):
-                                                    return book_data.get("book")
-                                            except json.JSONDecodeError:
-                                                continue
-                        return result
-                except json.JSONDecodeError:
-                    continue
-        
-        return None
-        
-    except Exception as e:
-        print(f"[DEBUG] Google Books MCP error: {e}")
-        return None
-
-
-
-
-def fetch_book_metadata(state: AgentState) -> AgentState:
-    """Node: Fetch metadata for retrieved books via Google Books API"""
-    print(f"[DEBUG AGENT] fetch_book_metadata node started with {len(state.get('retrieved_books', []))} books")
-
-    enriched_books = []
-    skipped_books = []
-    state["reasoning"].append(f"📖 Fetching metadata from Google Books (need {NUM_BOOKS_TO_RETRIEVE} with descriptions)...")
-
-    for book in state["retrieved_books"]:
-        # Stop once we have enough books with valid descriptions
-        if len(enriched_books) >= NUM_BOOKS_TO_RETRIEVE:
-            print(f"[DEBUG] Reached target of {NUM_BOOKS_TO_RETRIEVE} books, stopping")
-            break
-            
-        try:
-            # Use Google Books MCP server
-            metadata = call_google_books_mcp(book['title'], book['author'])
-
-            if metadata and metadata.get("title"):
-                description = metadata.get("description", "")
-                
-                # FILTER: Skip books without meaningful descriptions
-                if not description or len(description.strip()) < 50:
-                    skipped_books.append(book['title'])
-                    print(f"[DEBUG] Skipping '{book['title']}' - no/short description ({len(description.strip()) if description else 0} chars)")
-                    continue
-                
-                # Format authors as string
-                authors = metadata.get("authors", [])
-                author_str = ", ".join(authors) if isinstance(authors, list) else authors or book["author"]
-                
-                enriched_books.append({
-                    "title": metadata.get("title", book["title"]),
-                    "author": author_str,
-                    "description": description,
-                    "cover_url": metadata.get("thumbnail"),
-                    "isbn": metadata.get("isbn"),
-                    "published_year": metadata.get("published_date", "")[:4] if metadata.get("published_date") else None,
-                    "page_count": metadata.get("page_count"),
-                    "categories": metadata.get("categories", []),
-                    "preview_link": metadata.get("preview_link"),
-                    "info_link": metadata.get("info_link")
-                })
-                print(f"[DEBUG] Found metadata for: {book['title']} ({len(description)} chars) [{len(enriched_books)}/{NUM_BOOKS_TO_RETRIEVE}]")
-            else:
-                # No results found - skip
-                skipped_books.append(book['title'])
-                print(f"[DEBUG] Skipping '{book['title']}' - no Google Books results")
-
-        except Exception as e:
-            # On any error, skip the book
-            skipped_books.append(book['title'])
-            state["reasoning"].append(f"Error fetching metadata for '{book['title']}': {str(e)}")
-
-    state["books_with_metadata"] = enriched_books
-    
-    if skipped_books:
-        state["reasoning"].append(f"⚠️ Skipped {len(skipped_books)} books without descriptions")
-    state["reasoning"].append(f"✅ Found {len(enriched_books)}/{NUM_BOOKS_TO_RETRIEVE} books with full metadata")
-
-    return state
-
-
-def _generate_narrowing_question(state: AgentState, question_num: int) -> tuple:
-    """Helper: Generate a narrowing question"""
-    from prompts import NARROWING_QUESTION_GENERATOR
-    
-    books_summary_parts = []
-    for i, b in enumerate(state["books_with_metadata"], 1):
-        desc = b.get('description', 'No description')
-        cats = ', '.join(b.get('categories', [])) if b.get('categories') else 'Uncategorized'
-        books_summary_parts.append(f"Book {i}: {b['title']} by {b['author']}\n  Categories: {cats}\n  Description: {desc}")
-    books_summary = "\n\n".join(books_summary_parts)
-
-    vibe_context = f"Feels like: {state['feels_like']}\nAesthetics: {', '.join(state['aesthetic_genre_keywords'])}\nMood: {', '.join(state['mood_atmosphere'])}\nThemes: {', '.join(state['core_themes'])}"
-
-    is_last = question_num >= 2
-    question_context = f"This is question {question_num} of 2." + (" THIS IS THE LAST QUESTION - make it count!" if is_last else "")
-
-    user_prompt = f"Books to narrow down:\n{books_summary}\n\nVibe:\n{vibe_context}\n\nPrevious preferences: {json.dumps(state.get('user_preferences', {}), indent=2)}\n\n{question_context}\n\nGenerate an either/or question:"
-    
-    messages = [
-        {"role": "system", "content": NARROWING_QUESTION_GENERATOR},
-        {"role": "user", "content": user_prompt}
-    ]
-
-    return call_llm(messages, temperature=0.8, model=FAST_MODEL, include_reasoning=True)
-
-
-def generate_question_1(state: AgentState) -> AgentState:
-    """Node: Generate Q1 and add to messages"""
-    print(f"[DEBUG AGENT] generate_question_1")
-    
-    question, reasoning = _generate_narrowing_question(state, 1)
-    
-    state["narrowing_questions_asked"] = 1
-    state["q1_question"] = question
-    state["reasoning"].append(f"🧠 REASONING (Narrowing Question #1):\n{reasoning}\n\n→ Question: {question}")
-
-    assistant_message = f"To help me find the perfect match:\n\n{question}"
-    print(f"[DEBUG AGENT] Q1: {question[:60]}...")
-    
-    state["messages"].append({"role": "assistant", "content": assistant_message})
-    return state
-
-
-def wait_for_answer_1(state: AgentState) -> AgentState:
-    """Node: Wait for user's answer to Q1"""
-    print(f"[DEBUG AGENT] wait_for_answer_1")
-    
-    user_answer = interrupt("Waiting for Q1 answer")
-    if user_answer:
-        state["messages"].append({"role": "user", "content": user_answer})
-        state["user_preferences"]["q1"] = {
-            "question": state.get("q1_question", ""),
-            "answer": user_answer
-        }
-        print(f"[DEBUG AGENT] Q1 answered: {user_answer}")
-    return state
-
-
-def generate_question_2(state: AgentState) -> AgentState:
-    """Node: Generate Q2 and add to messages"""
-    print(f"[DEBUG AGENT] generate_question_2")
-    
-    question, reasoning = _generate_narrowing_question(state, 2)
-    
-    state["narrowing_questions_asked"] = 2
-    state["q2_question"] = question
-    state["reasoning"].append(f"🧠 REASONING (Narrowing Question #2):\n{reasoning}\n\n→ Question: {question}")
-
-    assistant_message = f"To help me find the perfect match:\n\n{question}"
-    print(f"[DEBUG AGENT] Q2: {question[:60]}...")
-    
-    state["messages"].append({"role": "assistant", "content": assistant_message})
-    return state
-
-
-def wait_for_answer_2(state: AgentState) -> AgentState:
-    """Node: Wait for user's answer to Q2"""
-    print(f"[DEBUG AGENT] wait_for_answer_2")
-    
-    user_answer = interrupt("Waiting for Q2 answer")
-    if user_answer:
-        state["messages"].append({"role": "user", "content": user_answer})
-        state["user_preferences"]["q2"] = {
-            "question": state.get("q2_question", ""),
-            "answer": user_answer
-        }
-        print(f"[DEBUG AGENT] Q2 answered: {user_answer}")
-    return state
-
-
-def check_narrowing_complete(state: AgentState) -> Literal["ask_more", "finalize"]:
-    """Conditional edge: Check if we've asked all 2 narrowing questions"""
-    questions_asked = state.get("narrowing_questions_asked", 0)
-    if questions_asked >= 2:
-        return "finalize"
-    return "ask_more"
-
-
-
-
-def finalize_books(state: AgentState) -> AgentState:
-    """Node: Use reasoning to select final 3 books based on vibe and preferences"""
-    print(f"[DEBUG AGENT] finalize_books node started")
-    print(f"[DEBUG AGENT] books_with_metadata count: {len(state.get('books_with_metadata', []))}")
-    from prompts import get_book_finalizer_prompt
-
-    # Build detailed book summary with full descriptions - no truncation
-    books_summary_parts = []
-    for i, b in enumerate(state["books_with_metadata"]):
-        desc = b.get('description', 'No description available')
-        cats = ', '.join(b.get('categories', [])) if b.get('categories') else 'Uncategorized'
-        books_summary_parts.append(f"{i+1}. {b['title']} by {b['author']}\n   Categories: {cats}\n   Description: {desc}")
-    books_summary = "\n\n".join(books_summary_parts)
-    
-    prefs_summary = json.dumps(state.get("user_preferences", {}), indent=2)
-    vibe_context = f"Feels like: {state['feels_like']}\nAesthetics: {', '.join(state['aesthetic_genre_keywords'])}\nMood: {', '.join(state['mood_atmosphere'])}\nThemes: {', '.join(state['core_themes'])}\nTropes: {', '.join(state['tropes'])}"
-
-    user_prompt = f"Vibe:\n{vibe_context}\n\nCandidate Books:\n{books_summary}\n\nUser Preferences (from Q&A):\n{prefs_summary}\n\nSelect the {NUM_FINAL_BOOKS} best matches (return only JSON array):"
-    
-    messages = [
-        {"role": "system", "content": get_book_finalizer_prompt(NUM_FINAL_BOOKS)},
-        {"role": "user", "content": user_prompt}
-    ]
-
-    print(f"[DEBUG AGENT] finalize_books user_prompt:\n{user_prompt}")
-
-    # Use reasoning model for book selection - this is a complex decision
-    # Increase max_tokens since we're sending full book descriptions
-    selection_response, reasoning = call_llm(messages, temperature=0.3, model=REASONING_MODEL, include_reasoning=True, max_tokens=4000)
-    
-    # Log reasoning even if empty
-    state["reasoning"].append(f"🧠 REASONING (Book Selection):\n{reasoning or 'No reasoning provided'}")
-
-    # Parse the JSON response - check both content and reasoning for the array
-    try:
-        import re
-        # First try to find JSON array in the response content
-        json_match = re.search(r'\[([\d,\s]+)\]', selection_response)
-        
-        # If not found in content, try to find it in reasoning (some models put answer there)
-        if not json_match and reasoning:
-            json_match = re.search(r'\[([\d,\s]+)\]', reasoning)
-            if json_match:
-                print(f"[DEBUG AGENT] Found JSON in reasoning instead of content")
-        
-        if json_match:
-            indices = json.loads(json_match.group(0))
-            selected_books = [state["books_with_metadata"][i-1] for i in indices if 0 < i <= len(state["books_with_metadata"])][:NUM_FINAL_BOOKS]
-        else:
-            # Fallback to first 3 books
-            print(f"[DEBUG AGENT] No JSON array found, using first 3 books")
-            selected_books = state["books_with_metadata"][:NUM_FINAL_BOOKS]
-    except Exception as e:
-        state["reasoning"].append(f"❌ Failed to parse book selection: {e}. Using first 3 books.")
-        selected_books = state["books_with_metadata"][:NUM_FINAL_BOOKS]
-
-    state["final_books"] = selected_books
-    state["reasoning"].append(f"🧠 REASONING (Book Selection):\n{reasoning}\n\n→ Selected: {[b['title'] for b in selected_books]}")
-
-    return state
-
-
-def generate_soundtrack(state: AgentState) -> AgentState:
-    """Node: Generate ambient soundtrack using ElevenLabs Music API"""
-    print(f"[DEBUG AGENT] generate_soundtrack node started")
-    
-    import requests
-    import tempfile
-
-    ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
-    print(f"[DEBUG AGENT] ELEVENLABS_API_KEY present: {bool(ELEVENLABS_API_KEY)}")
-    
-    if not ELEVENLABS_API_KEY:
-        print(f"[DEBUG AGENT] No ELEVENLABS_API_KEY - skipping")
-        state["reasoning"].append("⚠️ ELEVENLABS_API_KEY not set - skipping soundtrack generation")
-        state["soundtrack_url"] = ""
-        return state
-
-    try:
-        # Build vibe context for music prompt generation
-        vibe_context = {
-            "feels_like": state["feels_like"],
-            "mood_atmosphere": state["mood_atmosphere"],
-            "aesthetic_genre_keywords": state["aesthetic_genre_keywords"],
-            "core_themes": state["core_themes"],
-            "tropes": state["tropes"]
-        }
-        print(f"[DEBUG AGENT] vibe_context built: {list(vibe_context.keys())}")
-
-        # Use LLM to generate music prompt from vibe context
-        from prompts import MUSIC_PROMPT_GENERATION
-        
-        messages = [
-            {"role": "system", "content": MUSIC_PROMPT_GENERATION},
-            {"role": "user", "content": f"Generate a music prompt based on this vibe:\n{json.dumps(vibe_context, indent=2)}"}
-        ]
-        
-        print(f"[DEBUG AGENT] Calling LLM for music prompt...")
-        music_prompt, reasoning = call_llm(messages, temperature=0.7, model=FAST_MODEL, include_reasoning=True)
-        print(f"[DEBUG AGENT] Music prompt generated: {music_prompt[:100] if music_prompt else 'None'}...")
-        state["reasoning"].append(f"🎵 Music prompt: {music_prompt}")
-        
-        # Call ElevenLabs Music API directly
-        print(f"[DEBUG AGENT] Calling ElevenLabs Music API...")
-        state["reasoning"].append(f"🎵 Calling ElevenLabs Music API...")
-        
-        response = requests.post(
-            "https://api.elevenlabs.io/v1/music",
-            headers={
-                "xi-api-key": ELEVENLABS_API_KEY,
-                "Content-Type": "application/json"
-            },
-            json={
-                "prompt": music_prompt,
-                "music_length_ms": 90000,  # 1:30 minute
-                "force_instrumental": True  # No vocals, just ambient music
-            },
-            timeout=120  # Music generation can take a while
-        )
-        
-        print(f"[DEBUG AGENT] ElevenLabs response status: {response.status_code}")
-        
-        if response.status_code == 200:
-            print(f"[DEBUG AGENT] Success! Response size: {len(response.content)} bytes")
-            # Save the audio data to a temp file
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp3')
-            temp_file.write(response.content)
-            temp_file.close()
-            print(f"[DEBUG AGENT] Saved to temp file: {temp_file.name}")
-
-            state["soundtrack_url"] = temp_file.name
-            state["reasoning"].append(f"✅ Generated soundtrack successfully ({len(response.content)} bytes)")
-        else:
-            print(f"[DEBUG AGENT] ElevenLabs API error: {response.status_code} - {response.text[:500]}")
-            state["reasoning"].append(f"❌ ElevenLabs API error: {response.status_code} - {response.text[:200]}")
-            state["soundtrack_url"] = ""
-
-    except Exception as e:
-        import traceback
-        print(f"[DEBUG AGENT] Exception in generate_soundtrack: {e}")
-        traceback.print_exc()
-        state["reasoning"].append(f"❌ Failed to generate soundtrack: {e}")
-        state["soundtrack_url"] = ""
-
-    print(f"[DEBUG AGENT] generate_soundtrack finished, soundtrack_url: {state.get('soundtrack_url', 'not set')}")
-    return state
-
-
-def present_final_results(state: AgentState) -> AgentState:
-    """Node: Format and present final results to user"""
-
-    # Format books for display
-    books_text = "Here are your personalized book recommendations:\n\n"
-    for i, book in enumerate(state["final_books"], 1):
-        books_text += f"{i}. **{book['title']}** by {book['author']}\n"
-
-    state["messages"].append({
-        "role": "assistant",
-        "content": books_text + f"\n\nI'm also generating a soundtrack that matches your vibe! Scroll down for all the goodies ⬇️"
-    })
-
-    state["reasoning"].append("Presented final results to user")
-
-    return state
-
-
-# ============================================================================
-# GRAPH CONSTRUCTION
-# ============================================================================
-
-def create_agent_graph():
-    """Create and compile the LangGraph workflow with interrupts for user input"""
-    from langgraph.checkpoint.memory import MemorySaver
-
-    # Initialize graph
-    workflow = StateGraph(AgentState)
-
-    # Add nodes
-    workflow.add_node("generate_initial_vibe", generate_initial_vibe)
-    workflow.add_node("refine_vibe", refine_vibe)
-    workflow.add_node("retrieve_books", retrieve_books)
-    workflow.add_node("fetch_metadata", fetch_book_metadata)
-    workflow.add_node("generate_q1", generate_question_1)
-    workflow.add_node("wait_a1", wait_for_answer_1)
-    workflow.add_node("generate_q2", generate_question_2)
-    workflow.add_node("wait_a2", wait_for_answer_2)
-    workflow.add_node("finalize_books", finalize_books)
-    workflow.add_node("generate_soundtrack", generate_soundtrack)
-    workflow.add_node("present_results", present_final_results)
-
-    # Set entry point
-    workflow.set_entry_point("generate_initial_vibe")
-
-    # After initial vibe, check if user is satisfied or wants refinement
-    workflow.add_conditional_edges(
-        "generate_initial_vibe",
-        check_vibe_satisfaction,
-        {
-            "refine": "refine_vibe",
-            "retrieve": "retrieve_books"
-        }
-    )
-
-    # After refinement, check again if user is satisfied
-    workflow.add_conditional_edges(
-        "refine_vibe",
-        check_vibe_satisfaction,
-        {
-            "refine": "refine_vibe",
-            "retrieve": "retrieve_books"
-        }
-    )
-
-    # Sequential: retrieve -> fetch -> generate Q1 -> wait A1 -> generate Q2 -> wait A2 -> finalize
-    workflow.add_edge("retrieve_books", "fetch_metadata")
-    workflow.add_edge("fetch_metadata", "generate_q1")
-    workflow.add_edge("generate_q1", "wait_a1")
-    workflow.add_edge("wait_a1", "generate_q2")
-    workflow.add_edge("generate_q2", "wait_a2")
-    workflow.add_edge("wait_a2", "finalize_books")
-
-    # Sequential: finalize -> soundtrack -> present
-    workflow.add_edge("finalize_books", "generate_soundtrack")
-    workflow.add_edge("generate_soundtrack", "present_results")
-    workflow.add_edge("present_results", END)
-
-    # Compile with checkpointer for state persistence
-    memory = MemorySaver()
-    return workflow.compile(checkpointer=memory)
-
-
-# ============================================================================
-# MAIN INTERFACE
-# ============================================================================
-
-# Global graph instance with persistent checkpointer
-_GRAPH_INSTANCE = None
-
-def get_graph():
-    """Get or create the compiled graph with checkpointer"""
-    global _GRAPH_INSTANCE
-    if _GRAPH_INSTANCE is None:
-        print(f"[DEBUG AGENT] Creating NEW graph instance!")
-        _GRAPH_INSTANCE = create_agent_graph()
-    else:
-        print(f"[DEBUG AGENT] Reusing existing graph instance")
-    return _GRAPH_INSTANCE
-
-def reset_agent():
-    """Reset the agent by clearing the graph instance"""
-    global _GRAPH_INSTANCE
-    _GRAPH_INSTANCE = None
-
-def run_agent(images: List[str], user_message: str = None, thread_id: str = "main"):
-    """
-    Main interface to run the agent with interrupt-based human-in-the-loop
-
-    Args:
-        images: List of image URLs/base64 for initial upload
-        user_message: User's message (for resuming after interrupt)
-        thread_id: Unique identifier for the user session (required for multi-user support)
-
-    Returns:
-        Updated state with agent's response
-    """
-    from langgraph.types import Command
-
-    graph = get_graph()
-    thread_config = {"configurable": {"thread_id": thread_id}}
-
-    # Initialize state if new conversation (images provided)
-    if images and len(images) > 0:
-        initial_state = AgentState(
-            images=images,
-            messages=[],
-            aesthetic_genre_keywords=[],
-            mood_atmosphere=[],
-            core_themes=[],
-            tropes=[],
-            feels_like="",
-            vibe_refinement_count=0,
-            retrieved_books=[],
-            books_with_metadata=[],
-            q1_question="",
-            q2_question="",
-            user_preferences={},
-            final_books=[],
-            soundtrack_url="",
-            reasoning=[]
-        )
-        # Start the graph - it will stop at first interrupt()
-        result = graph.invoke(initial_state, thread_config)
-        return result
-
-    # Resume with user's message
-    if user_message:
-        # Check current state before resuming
-        current_state = graph.get_state(thread_config)
-        print(f"[DEBUG AGENT] State BEFORE resume:")
-        print(f"[DEBUG AGENT]   messages count: {len(current_state.values.get('messages', []))}")
-        for i, m in enumerate(current_state.values.get('messages', [])):
-            print(f"[DEBUG AGENT]   msg[{i}]: {m.get('role')} - {m.get('content', '')[:60]}...")
-        print(f"[DEBUG AGENT]   q1_question: '{current_state.values.get('q1_question', '')[:50] if current_state.values.get('q1_question') else 'EMPTY'}'")
-        
-        # Resume from the last interrupt; the value passed to Command(resume=...)
-        # is what the corresponding interrupt(...) call will return inside the node.
-        print(f"[DEBUG AGENT] Resuming graph with user_message: {user_message[:50]}...")
-        result = graph.invoke(Command(resume=user_message), thread_config)
-        print(f"[DEBUG AGENT] graph.invoke returned: {type(result)}, keys: {list(result.keys()) if hasattr(result, 'keys') else 'N/A'}")
-        print(f"[DEBUG AGENT] result has {len(result.get('messages', []))} messages")
-        
-        # Remove __interrupt__ key if present before returning
-        if "__interrupt__" in result:
-            result = {k: v for k, v in result.items() if k != "__interrupt__"}
-        return result
-
-    return None

app/custom.css

@@ -1,59 +0,0 @@
-@import url('https://fonts.googleapis.com/css2?family=Pixelify+Sans:wght@400;500;600;700&display=swap');
-
-body {
-    background-image: url('https://64.media.tumblr.com/677c7a2824b4c515b4c96b0cccb44740/tumblr_ney3botpbL1snc5kxo2_250.png');
-    background-repeat: repeat;
-    background-size: auto;
-}
-
-.gradio-container {
-    background-image: url('https://64.media.tumblr.com/677c7a2824b4c515b4c96b0cccb44740/tumblr_ney3botpbL1snc5kxo2_250.png');
-    background-repeat: repeat;
-    background-size: auto;
-}
-
-#main-title {
-    text-align: center;
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    background-clip: text;
-    font-weight: bold;
-    margin-bottom: 8px;
-    font-family: 'Pixelify Sans', sans-serif;
-}
-
-#subtitle {
-    text-align: center;
-    color: #1b0925;
-    margin-bottom: 30px;
-}
-
-.vibe-container {
-    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
-    border-radius: 15px;
-    padding: 20px;
-}
-
-.recommendation-section {
-    margin-top: 30px;
-}
-
-#status-display textarea {
-    font-size: 1.4em !important;
-    font-weight: 500;
-    background: transparent !important;
-}
-
-/* Chatbot message text */
-.chatbot .message-wrap {
-    font-size: 1.3em !important;
-}
-
-footer {
-    text-align: center;
-    margin-top: 50px;
-    padding: 20px;
-    color: #999;
-    font-size: 0.9em;
-}

app/prompts.py

@@ -1,156 +0,0 @@
-"""
-Centralized Prompts Configuration
-Store all system prompts and templates used across the vibe-reader application
-"""
-
-# ============================================================================
-# VIBE EXTRACTION PROMPTS
-# ============================================================================
-
-VIBE_EXTRACTION = """You are an expert at capturing the emotional essence and atmosphere of visual content. Your task is to analyze one or more images and translate their collective 'vibe' into a detailed description that would help someone find fiction books with a similar feeling and atmosphere.
-
-**Context:** This analysis will be used to recommend books based on visual mood boards, similar to how users on r/Booksthatfeellikethis share images to convey the type of story atmosphere they're seeking.
-
-**Key Instructions:**
-- Focus on the emotional atmosphere and feelings the images evoke, NOT literal descriptions of what's shown
-- Think like a reader who wants to be immersed in a world that feels like these images
-- When analyzing multiple images, treat them as a cohesive mood board that defines one unified vibe
-- Consider what it would feel like to live in or experience a story set in this atmosphere
-- Use natural, conversational language - be evocative but avoid overly poetic or academic terminology
-- If images seem to have conflicting vibes, find the common emotional thread that unifies them
-- Only reference specific time periods or cultures if the images clearly and obviously point to them
-- Avoid describing graphic violence even if present in the images
-
-**Target Output:** Your description should help match these vibes to fiction books across all genres.
-
-**Required Format:**
-
-You must output a valid JSON object with the following structure:
-
-{
-  "aesthetic_genre_keywords": ["keyword1", "keyword2", "keyword3"],
-  "mood_atmosphere": ["mood1", "mood2", "mood3"],
-  "core_themes": ["theme1", "theme2", "theme3"],
-  "tropes": ["trope1", "trope2", "trope3"],
-  "feels_like": "4-5 sentences that synthesize the overall emotional essence..."
-}
-
-Guidelines for each field:
-- **aesthetic_genre_keywords**: Style and genre descriptors like Gothic, Dark Academia, Cyberpunk, Cottagecore, Film Noir, Solarpunk, etc.
-- **mood_atmosphere**: Emotional tone - words like Melancholic, Nostalgic, Tense, Cozy, Dreamlike, Whimsical, Foreboding, etc.
-- **core_themes**: Broad underlying themes such as Isolation, Mystery, Self-discovery, Loss, Wonder, Coming-of-age, Redemption, Power and corruption, etc.
-- **tropes**: Specific narrative tropes and patterns like Enemies-to-lovers, Found family, Chosen one, Unreliable narrator, Slow burn romance, Morally gray protagonist, etc.
-- **feels_like**: Write 4-5 sentences that synthesize the overall emotional essence. Focus 60% on potential story atmosphere and subtle plot elements, 40% on pure mood. Describe what it would feel like to be immersed in a book with this atmosphere.
-
-IMPORTANT: Return ONLY the JSON object. Do not include markdown code blocks, backticks, or any text outside the JSON.
-"""
-
-
-# ============================================================================
-# VIBE REFINEMENT PROMPTS
-# ============================================================================
-
-VIBE_REFINEMENT = """You are helping refine a vibe description based on user feedback.
-
-IMPORTANT: 
-- If the user approves/accepts the vibe (says "yes", "perfect", "good", "love it", etc.), return the EXACT same description unchanged.
-- Only modify the description if the user explicitly asks for changes or suggests specific adjustments.
-
-When changes are requested, adjust the description to incorporate their suggestions while maintaining a natural, evocative tone."""
-
-
-# ============================================================================
-# BOOK SELECTION & NARROWING PROMPTS
-# ============================================================================
-
-NARROWING_QUESTION_GENERATOR = """You are helping narrow down book recommendations by finding the KEY DIFFERENCE between the candidate books.
-
-YOUR PROCESS:
-1. READ the book descriptions and categories carefully
-2. IDENTIFY a concrete differentiating factor that actually appears in the books (not abstract vibes)
-3. FORMULATE a question where Option A matches some books and Option B matches others
-
-GROUNDING RULES:
-- Your question MUST be based on ACTUAL content from the book descriptions/categories provided
-- Look for concrete differences: time period, setting type, protagonist type, plot focus, tone, narrative style
-- Do NOT invent abstract aesthetic questions that aren't grounded in the books
-- NEVER mention specific book titles or authors
-
-FORMAT RULES:
-- Use EXACTLY this format: "Do you prefer **A)** [option] or **B)** [option]?"
-- Keep options SHORT (under 10 words each)
-- The user should be able to answer with just "A" or "B"
-
-If previous preferences exist, your question must be COMPATIBLE with what the user already chose.
-
-Provide ONLY the question, no explanation."""
-
-
-BOOK_FINALIZER = """You are selecting the {num_books} best books from a list based on vibe and user preferences.
-
-You will receive:
-1. The vibe profile (aesthetics, mood, themes, tropes, feels_like)
-2. A list of candidate books with descriptions and categories
-3. User preferences from Q&A (question + answer pairs)
-
-Your task:
-- Analyze each book's description and categories against the vibe
-- Apply the user's stated preferences as HARD FILTERS — if they said they prefer X over Y, prioritize books matching X
-- Select the {num_books} books that best match BOTH the vibe AND the user's preferences
-
-Respond with ONLY a JSON array of book indices (1-indexed), like: [3, 7, 12]"""
-
-
-# ============================================================================
-# MUSIC GENERATION PROMPTS
-# ============================================================================
-
-MUSIC_PROMPT_GENERATION = """You are creating a music generation prompt for ElevenLabs based on a book vibe analysis. 
-Your task is to translate the literary atmosphere and emotional elements into a descriptive music prompt that will generate an appropriate instrumental soundtrack.
-
-Key Instructions:
-- Create instrumental ambient music that captures the emotional essence of the vibe
-- Focus on atmosphere, mood, and emotional tone - NOT specific story elements
-- Use descriptive musical terms (tempo, instrumentation, style, mood)
-- Consider how the music would feel as background for reading or immersing in this type of story
-- Aim for 30-60 second ambient pieces that set a mood
-- Avoid mentioning specific characters, plots, or narrative events
-- DO NOT reference specific artists or copyrighted works
-- Keep prompts concise but evocative (50-150 words)
-
-Musical Elements to Consider:
-- Tempo: slow, moderate, energetic
-- Instrumentation: piano, strings, electronic, ambient textures, orchestral
-- Style: ambient, classical, electronic, folk, cinematic
-- Mood: mysterious, peaceful, tense, whimsical, melancholic, etc.
-
-Output: A single descriptive prompt for ElevenLabs music generation."""
-
-
-# ============================================================================
-# USER SATISFACTION PROMPTS
-# ============================================================================
-
-VIBE_SATISFACTION_CHECKER = """Does the user want to change the vibe description? Reply with ONLY 'satisfied' or 'not_satisfied'.
-
-'satisfied' responses include: yes, yeah, perfect, good, love it, great, ok, okay, sure, sounds good, that works, etc.
-'not_satisfied' responses include: no, change it, more X, less Y, add Z, I want, make it, etc.
-
-Default to 'satisfied' unless the user EXPLICITLY requests changes."""
-
-
-# ============================================================================
-# HELPER FUNCTIONS
-# ============================================================================
-
-def get_book_finalizer_prompt(num_books: int = 3) -> str:
-    """
-    Get the book finalizer prompt with the specified number of books
-
-    Args:
-        num_books: Number of books to select (default: 3)
-
-    Returns:
-        The formatted system prompt string
-    """
-    return BOOK_FINALIZER.format(num_books=num_books)

app/requirements.txt

@@ -1,549 +0,0 @@
-# This file was autogenerated by uv via the following command:
-#    uv export --no-hashes --no-dev -o app/requirements.txt
--e .
-aiofiles==24.1.0
-    # via gradio
-aiohappyeyeballs==2.6.1
-    # via aiohttp
-aiohttp==3.13.2
-    # via modal
-aiosignal==1.4.0
-    # via aiohttp
-altair==6.0.0
-    # via vibe-reader
-annotated-doc==0.0.4
-    # via fastapi
-annotated-types==0.7.0
-    # via pydantic
-anthropic==0.72.1
-    # via vibe-reader
-anyio==4.11.0
-    # via
-    #   anthropic
-    #   gradio
-    #   httpx
-    #   mcp
-    #   openai
-    #   sse-starlette
-    #   starlette
-    #   watchfiles
-attrs==25.4.0
-    # via
-    #   aiohttp
-    #   jsonschema
-    #   referencing
-audioop-lts==0.2.2
-    # via gradio
-authlib==1.6.5
-    # via gradio
-blinker==1.9.0
-    # via flask
-brotli==1.2.0
-    # via gradio
-cbor2==5.7.1
-    # via modal
-certifi==2025.10.5
-    # via
-    #   httpcore
-    #   httpx
-    #   modal
-    #   requests
-cffi==2.0.0 ; implementation_name == 'pypy' or platform_python_implementation != 'PyPy'
-    # via
-    #   cryptography
-    #   pyzmq
-charset-normalizer==3.4.4
-    # via requests
-click==8.3.0
-    # via
-    #   flask
-    #   marimo
-    #   modal
-    #   typer
-    #   uvicorn
-colorama==0.4.6 ; sys_platform == 'win32'
-    # via
-    #   click
-    #   tqdm
-cryptography==46.0.3
-    # via
-    #   authlib
-    #   pyjwt
-distro==1.9.0
-    # via
-    #   anthropic
-    #   openai
-docstring-parser==0.17.0
-    # via anthropic
-docutils==0.22.3
-    # via marimo
-elevenlabs==2.24.0
-    # via vibe-reader
-faiss-cpu==1.13.0
-    # via vibe-reader
-fastapi==0.121.2
-    # via gradio
-ffmpy==1.0.0
-    # via gradio
-filelock==3.20.0
-    # via
-    #   huggingface-hub
-    #   torch
-    #   transformers
-flask==3.1.2
-    # via vibe-reader
-frozenlist==1.8.0
-    # via
-    #   aiohttp
-    #   aiosignal
-fsspec==2025.10.0
-    # via
-    #   gradio-client
-    #   huggingface-hub
-    #   torch
-gradio==6.0.1
-    # via vibe-reader
-gradio-client==2.0.0
-    # via gradio
-groovy==0.1.2
-    # via gradio
-grpclib==0.4.8
-    # via modal
-h11==0.16.0
-    # via
-    #   httpcore
-    #   uvicorn
-h2==4.3.0
-    # via grpclib
-hf-xet==1.2.0 ; platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'
-    # via huggingface-hub
-hpack==4.1.0
-    # via h2
-httpcore==1.0.9
-    # via httpx
-httpx==0.28.1
-    # via
-    #   anthropic
-    #   elevenlabs
-    #   gradio
-    #   gradio-client
-    #   langgraph-sdk
-    #   langsmith
-    #   mcp
-    #   openai
-    #   safehttpx
-httpx-sse==0.4.3
-    # via mcp
-huggingface-hub==0.36.0
-    # via
-    #   gradio
-    #   gradio-client
-    #   tokenizers
-    #   transformers
-hyperframe==6.1.0
-    # via h2
-idna==3.11
-    # via
-    #   anyio
-    #   httpx
-    #   requests
-    #   yarl
-itsdangerous==2.2.0
-    # via
-    #   flask
-    #   gradio
-    #   marimo
-jedi==0.19.2
-    # via marimo
-jinja2==3.1.6
-    # via
-    #   altair
-    #   flask
-    #   gradio
-    #   torch
-jiter==0.12.0
-    # via
-    #   anthropic
-    #   openai
-joblib==1.5.2
-    # via scikit-learn
-jsonpatch==1.33
-    # via langchain-core
-jsonpointer==3.0.0
-    # via jsonpatch
-jsonschema==4.25.1
-    # via
-    #   altair
-    #   mcp
-jsonschema-specifications==2025.9.1
-    # via jsonschema
-langchain-core==1.1.0
-    # via
-    #   langchain-nebius
-    #   langchain-openai
-    #   langgraph
-    #   langgraph-checkpoint
-    #   langgraph-prebuilt
-    #   vibe-reader
-langchain-nebius==0.1.3
-    # via vibe-reader
-langchain-openai==1.1.0
-    # via
-    #   langchain-nebius
-    #   vibe-reader
-langgraph==1.0.4
-    # via vibe-reader
-langgraph-checkpoint==3.0.1
-    # via
-    #   langgraph
-    #   langgraph-prebuilt
-langgraph-prebuilt==1.0.5
-    # via langgraph
-langgraph-sdk==0.2.10
-    # via langgraph
-langsmith==0.4.48
-    # via langchain-core
-loro==1.8.2 ; python_full_version < '3.14'
-    # via marimo
-marimo==0.17.7
-    # via vibe-reader
-markdown==3.10
-    # via
-    #   marimo
-    #   pymdown-extensions
-markdown-it-py==4.0.0
-    # via rich
-markupsafe==3.0.3
-    # via
-    #   flask
-    #   gradio
-    #   jinja2
-    #   werkzeug
-mcp==1.21.1
-    # via gradio
-mdurl==0.1.2
-    # via markdown-it-py
-modal==1.2.4
-    # via vibe-reader
-mpmath==1.3.0
-    # via sympy
-msgspec-m==0.19.2
-    # via marimo
-multidict==6.7.0
-    # via
-    #   aiohttp
-    #   grpclib
-    #   yarl
-narwhals==2.11.0
-    # via
-    #   altair
-    #   marimo
-    #   plotly
-networkx==3.6
-    # via torch
-numpy==2.3.4
-    # via
-    #   faiss-cpu
-    #   gradio
-    #   pandas
-    #   scikit-learn
-    #   scipy
-    #   torchvision
-    #   transformers
-nvidia-cublas-cu12==12.6.4.1 ; sys_platform == 'linux'
-    # via
-    #   nvidia-cudnn-cu12
-    #   nvidia-cusolver-cu12
-    #   torch
-nvidia-cuda-cupti-cu12==12.6.80 ; sys_platform == 'linux'
-    # via torch
-nvidia-cuda-nvrtc-cu12==12.6.77 ; sys_platform == 'linux'
-    # via torch
-nvidia-cuda-runtime-cu12==12.6.77 ; sys_platform == 'linux'
-    # via torch
-nvidia-cudnn-cu12==9.10.2.21 ; sys_platform == 'linux'
-    # via torch
-nvidia-cufft-cu12==11.3.0.4 ; sys_platform == 'linux'
-    # via torch
-nvidia-cufile-cu12==1.11.1.6 ; sys_platform == 'linux'
-    # via torch
-nvidia-curand-cu12==10.3.7.77 ; sys_platform == 'linux'
-    # via torch
-nvidia-cusolver-cu12==11.7.1.2 ; sys_platform == 'linux'
-    # via torch
-nvidia-cusparse-cu12==12.5.4.2 ; sys_platform == 'linux'
-    # via
-    #   nvidia-cusolver-cu12
-    #   torch
-nvidia-cusparselt-cu12==0.7.1 ; sys_platform == 'linux'
-    # via torch
-nvidia-nccl-cu12==2.27.5 ; sys_platform == 'linux'
-    # via torch
-nvidia-nvjitlink-cu12==12.6.85 ; sys_platform == 'linux'
-    # via
-    #   nvidia-cufft-cu12
-    #   nvidia-cusolver-cu12
-    #   nvidia-cusparse-cu12
-    #   torch
-nvidia-nvshmem-cu12==3.3.20 ; sys_platform == 'linux'
-    # via torch
-nvidia-nvtx-cu12==12.6.77 ; sys_platform == 'linux'
-    # via torch
-openai==2.8.0
-    # via
-    #   langchain-nebius
-    #   langchain-openai
-    #   vibe-reader
-orjson==3.11.4
-    # via
-    #   gradio
-    #   langgraph-sdk
-    #   langsmith
-ormsgpack==1.12.0
-    # via langgraph-checkpoint
-packaging==25.0
-    # via
-    #   altair
-    #   faiss-cpu
-    #   gradio
-    #   gradio-client
-    #   huggingface-hub
-    #   langchain-core
-    #   langsmith
-    #   marimo
-    #   plotly
-    #   transformers
-pandas==2.3.3
-    # via
-    #   gradio
-    #   vibe-reader
-parso==0.8.5
-    # via jedi
-pillow==11.3.0
-    # via
-    #   gradio
-    #   torchvision
-plotly==6.4.0
-    # via vibe-reader
-praw==7.8.1
-    # via vibe-reader
-prawcore==2.4.0
-    # via praw
-propcache==0.4.1
-    # via
-    #   aiohttp
-    #   yarl
-protobuf==6.33.1
-    # via modal
-psutil==7.1.3
-    # via marimo
-pycparser==2.23 ; (implementation_name != 'PyPy' and platform_python_implementation != 'PyPy') or (implementation_name == 'pypy' and platform_python_implementation == 'PyPy')
-    # via cffi
-pydantic==2.12.4
-    # via
-    #   anthropic
-    #   elevenlabs
-    #   fastapi
-    #   gradio
-    #   langchain-core
-    #   langgraph
-    #   langsmith
-    #   mcp
-    #   openai
-    #   pydantic-settings
-pydantic-core==2.41.5
-    # via
-    #   elevenlabs
-    #   pydantic
-pydantic-settings==2.12.0
-    # via mcp
-pydub==0.25.1
-    # via gradio
-pygments==2.19.2
-    # via
-    #   marimo
-    #   rich
-pyjwt==2.10.1
-    # via mcp
-pymdown-extensions==10.16.1
-    # via marimo
-python-dateutil==2.9.0.post0
-    # via pandas
-python-dotenv==1.2.1
-    # via
-    #   pydantic-settings
-    #   vibe-reader
-python-multipart==0.0.20
-    # via
-    #   gradio
-    #   mcp
-pytz==2025.2
-    # via pandas
-pywin32==311 ; sys_platform == 'win32'
-    # via mcp
-pyyaml==6.0.3
-    # via
-    #   gradio
-    #   huggingface-hub
-    #   langchain-core
-    #   marimo
-    #   pymdown-extensions
-    #   transformers
-pyzmq==27.1.0
-    # via vibe-reader
-referencing==0.37.0
-    # via
-    #   jsonschema
-    #   jsonschema-specifications
-regex==2025.11.3
-    # via
-    #   tiktoken
-    #   transformers
-requests==2.32.5
-    # via
-    #   elevenlabs
-    #   huggingface-hub
-    #   langsmith
-    #   prawcore
-    #   requests-toolbelt
-    #   tiktoken
-    #   transformers
-    #   update-checker
-    #   vibe-reader
-requests-toolbelt==1.0.0
-    # via langsmith
-rich==14.2.0
-    # via
-    #   modal
-    #   typer
-rpds-py==0.28.0
-    # via
-    #   jsonschema
-    #   referencing
-ruff==0.14.6
-    # via vibe-reader
-safehttpx==0.1.7
-    # via gradio
-safetensors==0.7.0
-    # via transformers
-scikit-learn==1.7.2
-    # via vibe-reader
-scipy==1.16.3
-    # via scikit-learn
-semantic-version==2.10.0
-    # via gradio
-setuptools==80.9.0
-    # via torch
-shellingham==1.5.4
-    # via typer
-six==1.17.0
-    # via python-dateutil
-sniffio==1.3.1
-    # via
-    #   anthropic
-    #   anyio
-    #   openai
-sse-starlette==3.0.3
-    # via mcp
-starlette==0.49.3
-    # via
-    #   fastapi
-    #   gradio
-    #   marimo
-    #   mcp
-sympy==1.14.0
-    # via torch
-synchronicity==0.10.5
-    # via modal
-tenacity==9.1.2
-    # via langchain-core
-threadpoolctl==3.6.0
-    # via scikit-learn
-tiktoken==0.12.0
-    # via langchain-openai
-tokenizers==0.22.1
-    # via transformers
-toml==0.10.2
-    # via modal
-tomlkit==0.13.3
-    # via
-    #   gradio
-    #   marimo
-torch==2.9.1+cu126
-    # via
-    #   torchvision
-    #   vibe-reader
-torchvision==0.24.1 ; python_full_version < '3.15' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux'
-    # via vibe-reader
-torchvision==0.24.1+cu126 ; python_full_version >= '3.15' or platform_machine != 'aarch64' or platform_python_implementation != 'CPython' or sys_platform != 'linux'
-    # via vibe-reader
-tqdm==4.67.1
-    # via
-    #   huggingface-hub
-    #   openai
-    #   transformers
-    #   vibe-reader
-transformers==4.57.1
-    # via vibe-reader
-triton==3.5.1 ; sys_platform == 'linux'
-    # via torch
-typer==0.20.0
-    # via
-    #   gradio
-    #   modal
-    #   vibe-reader
-types-certifi==2021.10.8.3
-    # via modal
-types-toml==0.10.8.20240310
-    # via modal
-typing-extensions==4.15.0
-    # via
-    #   altair
-    #   anthropic
-    #   elevenlabs
-    #   fastapi
-    #   gradio
-    #   gradio-client
-    #   huggingface-hub
-    #   langchain-core
-    #   mcp
-    #   modal
-    #   openai
-    #   pydantic
-    #   pydantic-core
-    #   synchronicity
-    #   torch
-    #   typer
-    #   typing-inspection
-typing-inspection==0.4.2
-    # via
-    #   mcp
-    #   pydantic
-    #   pydantic-settings
-tzdata==2025.2
-    # via pandas
-update-checker==0.18.0
-    # via praw
-urllib3==2.5.0
-    # via requests
-uvicorn==0.38.0
-    # via
-    #   gradio
-    #   marimo
-    #   mcp
-watchfiles==1.1.1
-    # via modal
-websocket-client==1.9.0
-    # via praw
-websockets==15.0.1
-    # via
-    #   elevenlabs
-    #   marimo
-werkzeug==3.1.4
-    # via flask
-xxhash==3.6.0
-    # via langgraph
-yarl==1.22.0
-    # via aiohttp
-zstandard==0.25.0
-    # via langsmith

app/utils.py

@@ -1,70 +0,0 @@
-"""
-Utility functions for the vibe-reader application
-"""
-
-import json
-import re
-from typing import Dict, Any, Optional
-
-
-def parse_json_response(response: str) -> Optional[Dict[str, Any]]:
-    """
-    Parse JSON from LLM response, handling various formats
-
-    Args:
-        response: Raw LLM response that may contain JSON
-
-    Returns:
-        Parsed JSON dict, or None if parsing fails
-    """
-    # Remove markdown code blocks if present
-    cleaned = re.sub(r'```json\s*|\s*```', '', response, flags=re.IGNORECASE)
-    cleaned = cleaned.strip()
-
-    # Try to find JSON object in the response
-    json_match = re.search(r'\{.*\}', cleaned, re.DOTALL)
-    if json_match:
-        try:
-            return json.loads(json_match.group(0))
-        except json.JSONDecodeError as e:
-            print(f"JSON parsing error: {e}")
-            return None
-
-    return None
-
-
-def extract_vibe_components(vibe_json: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Extract and validate vibe components from parsed JSON
-
-    Args:
-        vibe_json: Parsed JSON from vibe extraction
-
-    Returns:
-        Dictionary with validated vibe components
-    """
-    return {
-        "aesthetic_genre_keywords": vibe_json.get("aesthetic_genre_keywords", []),
-        "mood_atmosphere": vibe_json.get("mood_atmosphere", []),
-        "core_themes": vibe_json.get("core_themes", []),
-        "tropes": vibe_json.get("tropes", []),
-        "feels_like": vibe_json.get("feels_like", "")
-    }
-
-
-def strip_thinking_tags(text: str) -> str:
-    """
-    Remove <think>...</think> tags and any reasoning content from text
-    Qwen3 uses standard XML format: <think>...</think>
-
-    Args:
-        text: Text that may contain thinking tags
-
-    Returns:
-        Clean text without thinking tags
-    """
-    # Remove <think>...</think> blocks
-    cleaned = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL | re.IGNORECASE)
-    # Remove any leftover tags
-    cleaned = re.sub(r'</?think>', '', cleaned, flags=re.IGNORECASE)
-    return cleaned.strip()