test: Add conversational flow and LLM context tests

New test classes:
- TestConversationalFlow: Multi-turn conversations, history handling
- TestLLMContextPassing: Verify correct context sent to LLM

Tests verify:
- Follow-up questions work with history
- User messages preserved in history
- System prompts instruct RAG behavior
- User questions included in LLM prompts
- Relevant video content passed as context

Total: 64 tests

tests/test_app.py

@@ -859,3 +859,334 @@ class TestGetKnowledgeStatsWithSession:
         # Should show chunk count and video count
         assert "chunks" in result.lower() or "2" in result
         assert "Test Video" in result
+
+
+class TestConversationalFlow:
+    """Tests for multi-turn conversational interactions with the chatbot."""
+
+    def test_multi_turn_conversation(self):
+        """Test that chatbot can handle follow-up questions using history."""
+        from app import SessionState, add_to_vector_db, handle_chat
+
+        state = SessionState("convo_test_1")
+
+        # Add content about a cooking video
+        add_to_vector_db(
+            title="Italian Cooking",
+            transcript="Today we make authentic Italian pasta. First boil water. Add salt. "
+                       "Cook pasta for 8 minutes. The sauce uses fresh tomatoes, garlic, and basil.",
+            visual_contexts=["Chef chopping tomatoes", "Boiling pot of pasta"],
+            session_state=state,
+        )
+
+        mock_profile = MagicMock()
+        mock_token = MagicMock()
+        mock_token.token = "test_token"
+
+        with patch("app.InferenceClient") as mock_client:
+            # First question
+            mock_response1 = MagicMock()
+            mock_response1.choices = [MagicMock()]
+            mock_response1.choices[0].message.content = "The video shows how to make Italian pasta with a tomato sauce."
+
+            # Follow-up question
+            mock_response2 = MagicMock()
+            mock_response2.choices = [MagicMock()]
+            mock_response2.choices[0].message.content = "The sauce ingredients are fresh tomatoes, garlic, and basil."
+
+            mock_client.return_value.chat.completions.create.side_effect = [mock_response1, mock_response2]
+
+            # First turn
+            history1, _, state = handle_chat(
+                message="What is this video about?",
+                history=[],
+                session_state=state,
+                profile=mock_profile,
+                oauth_token=mock_token,
+            )
+
+            first_turn_len = len(history1)
+            assert first_turn_len >= 2
+            assert "pasta" in history1[-1]["content"].lower() or "Italian" in history1[-1]["content"]
+
+            # Second turn - follow-up question using history
+            history2, _, state = handle_chat(
+                message="What ingredients are in the sauce?",
+                history=history1,  # Pass previous history
+                session_state=state,
+                profile=mock_profile,
+                oauth_token=mock_token,
+            )
+
+            # Should have more messages now (history is mutated in place)
+            assert len(history2) == 4  # 2 turns x 2 messages each
+            # Last response should be about ingredients
+            assert "tomatoes" in history2[-1]["content"].lower() or "sauce" in history2[-1]["content"].lower()
+
+    def test_history_preserves_context(self):
+        """Test that conversation history preserves context for follow-ups."""
+        from app import SessionState, add_to_vector_db, handle_chat
+
+        state = SessionState("convo_test_2")
+
+        # Add content
+        add_to_vector_db(
+            title="Python Tutorial",
+            transcript="Python is a programming language. Variables store data. "
+                       "Functions are defined with def keyword. Classes use the class keyword.",
+            visual_contexts=["Code editor showing Python"],
+            session_state=state,
+        )
+
+        mock_profile = MagicMock()
+        mock_token = MagicMock()
+        mock_token.token = "test_token"
+
+        with patch("app.InferenceClient") as mock_client:
+            mock_response = MagicMock()
+            mock_response.choices = [MagicMock()]
+            mock_response.choices[0].message.content = "Functions are defined using the def keyword."
+            mock_client.return_value.chat.completions.create.return_value = mock_response
+
+            # Build up a conversation
+            history = []
+
+            # Turn 1: Ask about functions
+            history, _, state = handle_chat(
+                message="How do you define functions in Python?",
+                history=history,
+                session_state=state,
+                profile=mock_profile,
+                oauth_token=mock_token,
+            )
+
+            # Verify history structure
+            assert len(history) == 2  # User + Assistant
+            assert history[0]["role"] == "user"
+            assert history[1]["role"] == "assistant"
+            assert "function" in history[0]["content"].lower()
+
+    def test_user_messages_added_to_history(self):
+        """Test that user messages are properly added to history."""
+        from app import SessionState, handle_chat
+
+        state = SessionState("convo_test_3")
+        mock_profile = MagicMock()
+
+        history, _, state = handle_chat(
+            message="Hello chatbot!",
+            history=[],
+            session_state=state,
+            profile=mock_profile,
+            oauth_token=MagicMock(),
+        )
+
+        # User message should be in history
+        user_messages = [h for h in history if h["role"] == "user"]
+        assert len(user_messages) >= 1
+        assert user_messages[0]["content"] == "Hello chatbot!"
+
+    def test_assistant_responses_added_to_history(self):
+        """Test that assistant responses are properly added to history."""
+        from app import SessionState, add_to_vector_db, handle_chat
+
+        state = SessionState("convo_test_4")
+
+        add_to_vector_db(
+            title="Test",
+            transcript="Test content.",
+            visual_contexts=[],
+            session_state=state,
+        )
+
+        mock_profile = MagicMock()
+        mock_token = MagicMock()
+        mock_token.token = "test"
+
+        with patch("app.InferenceClient") as mock_client:
+            mock_response = MagicMock()
+            mock_response.choices = [MagicMock()]
+            mock_response.choices[0].message.content = "This is my response."
+            mock_client.return_value.chat.completions.create.return_value = mock_response
+
+            history, _, _ = handle_chat(
+                message="Tell me about the test",
+                history=[],
+                session_state=state,
+                profile=mock_profile,
+                oauth_token=mock_token,
+            )
+
+            # Assistant message should be in history
+            assistant_messages = [h for h in history if h["role"] == "assistant"]
+            assert len(assistant_messages) >= 1
+
+    def test_can_ask_about_specific_parts(self):
+        """Test asking specific questions about video content."""
+        from app import SessionState, add_to_vector_db, search_knowledge
+
+        state = SessionState("specific_test")
+
+        # Add detailed content
+        add_to_vector_db(
+            title="Science Documentary",
+            transcript="The documentary covers three topics. First, black holes are massive objects. "
+                       "Second, neutron stars are extremely dense. Third, galaxies contain billions of stars.",
+            visual_contexts=[
+                "Animation of black hole",
+                "Diagram of neutron star",
+                "Hubble image of galaxy",
+            ],
+            session_state=state,
+        )
+
+        # Search for specific topic
+        results = search_knowledge("black holes", session_state=state)
+        assert len(results) > 0
+        assert any("black hole" in r["content"].lower() for r in results)
+
+        # Search for another topic
+        results = search_knowledge("neutron stars", session_state=state)
+        assert len(results) > 0
+        assert any("neutron" in r["content"].lower() for r in results)
+
+        # Search for visual content
+        results = search_knowledge("galaxy image", session_state=state)
+        assert len(results) > 0
+
+
+class TestLLMContextPassing:
+    """Tests to verify correct context is passed to the LLM."""
+
+    def test_context_includes_relevant_video_content(self):
+        """Test that the LLM receives relevant video content in its prompt."""
+        from app import SessionState, add_to_vector_db, chat_with_videos
+
+        state = SessionState("context_test_1")
+
+        add_to_vector_db(
+            title="Machine Learning Basics",
+            transcript="Neural networks consist of layers. Input layer, hidden layers, and output layer.",
+            visual_contexts=["Diagram of neural network architecture"],
+            session_state=state,
+        )
+
+        mock_profile = MagicMock()
+        mock_token = MagicMock()
+        mock_token.token = "test"
+
+        captured_messages = None
+
+        with patch("app.InferenceClient") as mock_client:
+            def capture_call(*args, **kwargs):
+                nonlocal captured_messages
+                captured_messages = kwargs.get("messages", [])
+                mock_resp = MagicMock()
+                mock_resp.choices = [MagicMock()]
+                mock_resp.choices[0].message.content = "Response"
+                return mock_resp
+
+            mock_client.return_value.chat.completions.create.side_effect = capture_call
+
+            chat_with_videos(
+                message="Tell me about neural networks",
+                history=[],
+                profile=mock_profile,
+                oauth_token=mock_token,
+                session_state=state,
+            )
+
+            # Verify the context was passed to LLM
+            assert captured_messages is not None
+            assert len(captured_messages) == 2  # system + user
+
+            # User message should contain the video content
+            user_msg = captured_messages[1]["content"]
+            assert "neural" in user_msg.lower()
+            assert "layers" in user_msg.lower()
+
+    def test_system_prompt_instructs_rag_behavior(self):
+        """Test that system prompt instructs LLM to use provided context."""
+        from app import SessionState, add_to_vector_db, chat_with_videos
+
+        state = SessionState("context_test_2")
+
+        add_to_vector_db(
+            title="Test",
+            transcript="Content here.",
+            visual_contexts=[],
+            session_state=state,
+        )
+
+        mock_profile = MagicMock()
+        mock_token = MagicMock()
+        mock_token.token = "test"
+
+        captured_messages = None
+
+        with patch("app.InferenceClient") as mock_client:
+            def capture_call(*args, **kwargs):
+                nonlocal captured_messages
+                captured_messages = kwargs.get("messages", [])
+                mock_resp = MagicMock()
+                mock_resp.choices = [MagicMock()]
+                mock_resp.choices[0].message.content = "Response"
+                return mock_resp
+
+            mock_client.return_value.chat.completions.create.side_effect = capture_call
+
+            chat_with_videos(
+                message="Question",
+                history=[],
+                profile=mock_profile,
+                oauth_token=mock_token,
+                session_state=state,
+            )
+
+            # System prompt should instruct RAG behavior
+            system_msg = captured_messages[0]["content"]
+            assert "video" in system_msg.lower()
+            assert "context" in system_msg.lower()
+
+    def test_user_question_included_in_prompt(self):
+        """Test that the user's actual question is included in the prompt."""
+        from app import SessionState, add_to_vector_db, chat_with_videos
+
+        state = SessionState("context_test_3")
+
+        add_to_vector_db(
+            title="Test",
+            transcript="Content.",
+            visual_contexts=[],
+            session_state=state,
+        )
+
+        mock_profile = MagicMock()
+        mock_token = MagicMock()
+        mock_token.token = "test"
+
+        specific_question = "What are the three main ingredients mentioned?"
+        captured_messages = None
+
+        with patch("app.InferenceClient") as mock_client:
+            def capture_call(*args, **kwargs):
+                nonlocal captured_messages
+                captured_messages = kwargs.get("messages", [])
+                mock_resp = MagicMock()
+                mock_resp.choices = [MagicMock()]
+                mock_resp.choices[0].message.content = "Response"
+                return mock_resp
+
+            mock_client.return_value.chat.completions.create.side_effect = capture_call
+
+            chat_with_videos(
+                message=specific_question,
+                history=[],
+                profile=mock_profile,
+                oauth_token=mock_token,
+                session_state=state,
+            )
+
+            # User's question should be in the prompt
+            user_msg = captured_messages[1]["content"]
+            assert specific_question in user_msg