Add local LLM integration support

- Add support for local LLM servers (e.g., LM Studio) on port 1234
- Enable local mode via URL parameter (?local=true)
- Implement automatic response cleaning for local LLM output artifacts
- Add test scripts for validating local LLM integration
- Update documentation with local LLM setup instructions
- No API key required for local mode operation

.claude/settings.local.json

@@ -0,0 +1,15 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git checkout:*)",
+      "Bash(cp:*)",
+      "Bash(rm:*)",
+      "Bash(git commit:*)",
+      "Bash(git push:*)",
+      "Bash(git add:*)",
+      "Bash(grep:*)",
+      "Bash(node:*)"
+    ],
+    "deny": []
+  }
+}

CLAUDE.local.md

@@ -0,0 +1,2 @@
+- DO NOT SIGN OFF COMMIT MESSAGES WITH CLAUDE AS AN AUTHOR
+- Remember to review this file at the end of prompt engineering related changes or when the user tells you to or at the end of a long session. If changes have been made to OpenRouter prompt language or programming logic, low or high level, then update this file accordingly.

README.md

@@ -37,7 +37,7 @@ An interactive cloze reading practice application with AI-powered assistance. Pr
 
 ## Technology
 
-Built with vanilla JavaScript, powered by AI for intelligent word selection and contextual assistance.
+Built with vanilla JavaScript, powered by AI for intelligent word selection and contextual assistance. Supports both OpenRouter API and local LLM integration.
 
 ## Running Locally with Docker
 
@@ -60,6 +60,31 @@ To run the Cloze Reader application locally using Docker:
 - Docker installed on your system
 - Port 7860 available on your machine
 
+## Local LLM Integration
+
+The `local-llm-integration` branch adds support for running with a local LLM server instead of OpenRouter API:
+
+### Setup
+1. **Start your local LLM server** on port 1234 (e.g., using LM Studio with Gemma-3-12b)
+2. **Run the development server**:
+   ```bash
+   make dev  # or python3 local-server.py 8000
+   ```
+3. **Access with local LLM**:
+   - Navigate to `http://localhost:8000/index.html?local=true`
+   - The `?local=true` parameter switches from OpenRouter to your local LLM
+
+### Local LLM Features
+- **No API key required** - works entirely offline with your local model
+- **Automatic response cleaning** - handles local LLM output artifacts
+- **Compatible with LM Studio** and other OpenAI-compatible local servers
+- **Same game experience** - all features work identically to cloud version
+
+### Testing Local Integration
+- Test page: `http://localhost:8000/test-local-llm.html?local=true`
+- Stress test script: `node test-local-llm.js`
+- Direct integration test available in test files
+
 ## Architecture
 This is a **vanilla JavaScript modular application** with no build step. Key architectural patterns:
 

src/aiService.js

@@ -1,11 +1,31 @@
 class OpenRouterService {
   constructor() {
-    this.apiUrl = 'https://openrouter.ai/api/v1/chat/completions';
+    // Check for local LLM mode
+    this.isLocalMode = this.checkLocalMode();
+    this.apiUrl = this.isLocalMode ? 'http://localhost:1234/v1/chat/completions' : 'https://openrouter.ai/api/v1/chat/completions';
     this.apiKey = this.getApiKey();
-    this.model = 'google/gemma-3-27b-it:free';
+    this.model = this.isLocalMode ? 'gemma-3-12b' : 'google/gemma-3-27b-it:free';
+    
+    console.log('AI Service initialized:', {
+      mode: this.isLocalMode ? 'Local LLM' : 'OpenRouter',
+      url: this.apiUrl,
+      model: this.model
+    });
+  }
+  
+  checkLocalMode() {
+    if (typeof window !== 'undefined' && window.location) {
+      const urlParams = new URLSearchParams(window.location.search);
+      return urlParams.get('local') === 'true';
+    }
+    return false;
   }
 
   getApiKey() {
+    // Local mode doesn't need API key
+    if (this.isLocalMode) {
+      return 'local-mode-no-key';
+    }
     if (typeof process !== 'undefined' && process.env && process.env.OPENROUTER_API_KEY) {
       return process.env.OPENROUTER_API_KEY;
     }
@@ -51,14 +71,20 @@ class OpenRouterService {
     }
 
     try {
+      const headers = {
+        'Content-Type': 'application/json'
+      };
+      
+      // Only add auth headers for OpenRouter
+      if (!this.isLocalMode) {
+        headers['Authorization'] = `Bearer ${this.apiKey}`;
+        headers['HTTP-Referer'] = window.location.origin;
+        headers['X-Title'] = 'Cloze Reader';
+      }
+      
       const response = await fetch(this.apiUrl, {
         method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.apiKey}`,
-          'HTTP-Referer': window.location.origin,
-          'X-Title': 'Cloze Reader'
-        },
+        headers,
         body: JSON.stringify({
           model: this.model,
           messages: [{
@@ -200,11 +226,35 @@ Passage: "${passage}"`
           throw new Error('API response missing expected content');
         }
         
-        const content = data.choices[0].message.content.trim();
+        let content = data.choices[0].message.content.trim();
+        
+        // Clean up local LLM artifacts
+        if (this.isLocalMode) {
+          content = this.cleanLocalLLMResponse(content);
+        }
         
         // Try to parse as JSON array
         try {
-          const words = JSON.parse(content);
+          let words;
+          
+          // For local LLM, try different parsing strategies
+          if (this.isLocalMode) {
+            // Try JSON parse first
+            try {
+              words = JSON.parse(content);
+            } catch {
+              // If not JSON, try comma-separated
+              if (content.includes(',')) {
+                words = content.split(',').map(w => w.trim());
+              } else {
+                // Single word
+                words = [content.trim()];
+              }
+            }
+          } else {
+            words = JSON.parse(content);
+          }
+          
           if (Array.isArray(words)) {
             // Filter problematic words and validate word lengths based on level
             const problematicWords = ['negro', 'retard', 'retarded', 'nigger', 'chinaman', 'jap', 'gypsy', 'savage', 'primitive', 'heathen'];
@@ -302,14 +352,20 @@ Passage: "${passage}"`
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), 15000); // 15 second timeout
       
+      const headers = {
+        'Content-Type': 'application/json'
+      };
+      
+      // Only add auth headers for OpenRouter
+      if (!this.isLocalMode) {
+        headers['Authorization'] = `Bearer ${this.apiKey}`;
+        headers['HTTP-Referer'] = window.location.origin;
+        headers['X-Title'] = 'Cloze Reader';
+      }
+      
       const response = await fetch(this.apiUrl, {
         method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.apiKey}`,
-          'HTTP-Referer': window.location.origin,
-          'X-Title': 'Cloze Reader'
-        },
+        headers,
         signal: controller.signal,
         body: JSON.stringify({
           model: this.model,
@@ -604,6 +660,16 @@ Return as JSON: {"passage1": {...}, "passage2": {...}}`
     }
   }
 
+  cleanLocalLLMResponse(content) {
+    // Remove common artifacts from local LLM responses
+    return content
+      .replace(/\["?/g, '')       // Remove opening bracket and quote
+      .replace(/"?\]/g, '')       // Remove closing quote and bracket  
+      .replace(/^[>"|']+/g, '')   // Remove leading > or quotes
+      .replace(/[>"|']+$/g, '')   // Remove trailing > or quotes
+      .replace(/\\n/g, ' ')       // Replace escaped newlines
+      .trim();
+  }
 }
 
 export { OpenRouterService as AIService };

test-direct.js

@@ -0,0 +1,28 @@
+import { AIService } from './src/aiService.js';
+
+// Force local mode
+const originalSearch = window.location.search;
+window.location.search = '?local=true';
+
+const ai = new AIService();
+
+console.log('Testing direct AI connection...');
+console.log('Config:', {
+  url: ai.apiUrl,
+  model: ai.model,
+  isLocal: ai.isLocalMode
+});
+
+const testPassage = "The ancient library contained thousands of manuscripts, each one carefully preserved by generations of scholars who dedicated their lives to knowledge.";
+
+try {
+  console.log('\nTesting word selection...');
+  const words = await ai.selectSignificantWords(testPassage, 2, 3);
+  console.log('Selected words:', words);
+  console.log('✅ Success!');
+} catch (error) {
+  console.error('❌ Error:', error.message);
+}
+
+// Restore original search
+window.location.search = originalSearch;

test-local-llm.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+// Stress test for local LLM on port 1234
+// Tests word selection functionality with Gutenberg passages
+
+import http from 'http';
+
+// Sample Gutenberg passages for testing
+const testPassages = [
+  "The sun was shining brightly on the sea, shining with all his might. He did his very best to make the billows smooth and bright. And this was odd, because it was the middle of the night.",
+  "It was the best of times, it was the worst of times, it was the age of wisdom, it was the age of foolishness, it was the epoch of belief, it was the epoch of incredulity.",
+  "In a hole in the ground there lived a hobbit. Not a nasty, dirty, wet hole, filled with the ends of worms and an oozy smell, nor yet a dry, bare, sandy hole with nothing in it to sit down on.",
+  "Call me Ishmael. Some years ago—never mind how long precisely—having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little.",
+  "It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want of a wife. However little known the feelings or views of such a man may be."
+];
+
+// Word selection prompt template (based on cloze reader's format)
+function createWordSelectionPrompt(passage, level = 1) {
+  const wordCount = level < 6 ? 1 : level < 11 ? 2 : 3;
+  const minLength = level < 3 ? 4 : 5;
+  const maxLength = level < 3 ? 7 : level < 5 ? 10 : 14;
+  
+  return {
+    model: "gemma-3-12b",
+    messages: [
+      {
+        role: "system",
+        content: "You are a vocabulary expert who selects appropriate words for cloze exercises."
+      },
+      {
+        role: "user",
+        content: `Select ${wordCount} word${wordCount > 1 ? 's' : ''} from this passage for a cloze exercise.
+
+Passage: "${passage}"
+
+Requirements:
+- Select exactly ${wordCount} different word${wordCount > 1 ? 's' : ''}
+- Each word must be ${minLength}-${maxLength} letters long
+- Words must be meaningful nouns, verbs, adjectives, or adverbs
+- Avoid pronouns, articles, and common words
+- Return ONLY the selected word${wordCount > 1 ? 's' : ''}, ${wordCount > 1 ? 'comma-separated' : 'nothing else'}
+
+Selected word${wordCount > 1 ? 's' : ''}:`
+      }
+    ],
+    temperature: 0.7,
+    max_tokens: 50
+  };
+}
+
+// Function to make HTTP request to local LLM
+function testLLMConnection(passage, testNumber) {
+  return new Promise((resolve, reject) => {
+    const prompt = createWordSelectionPrompt(passage, Math.floor(Math.random() * 10) + 1);
+    const data = JSON.stringify(prompt);
+    
+    const options = {
+      hostname: 'localhost',
+      port: 1234,
+      path: '/v1/chat/completions',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': data.length
+      }
+    };
+    
+    console.log(`\n=== Test ${testNumber} ===`);
+    console.log(`Passage: "${passage.substring(0, 80)}..."`);
+    console.log(`Sending request to http://localhost:1234/v1/chat/completions`);
+    
+    const startTime = Date.now();
+    
+    const req = http.request(options, (res) => {
+      let responseData = '';
+      
+      res.on('data', (chunk) => {
+        responseData += chunk;
+      });
+      
+      res.on('end', () => {
+        const elapsed = Date.now() - startTime;
+        console.log(`Response received in ${elapsed}ms`);
+        console.log(`Status: ${res.statusCode}`);
+        
+        try {
+          const parsed = JSON.parse(responseData);
+          if (parsed.choices && parsed.choices[0] && parsed.choices[0].message) {
+            const selectedWords = parsed.choices[0].message.content.trim();
+            console.log(`Selected words: ${selectedWords}`);
+            console.log(`✓ Test ${testNumber} PASSED`);
+            resolve({ success: true, words: selectedWords, time: elapsed });
+          } else {
+            console.log(`Response structure unexpected:`, parsed);
+            resolve({ success: false, error: 'Invalid response structure', time: elapsed });
+          }
+        } catch (error) {
+          console.log(`Failed to parse response:`, error.message);
+          console.log(`Raw response:`, responseData.substring(0, 200));
+          resolve({ success: false, error: error.message, time: elapsed });
+        }
+      });
+    });
+    
+    req.on('error', (error) => {
+      const elapsed = Date.now() - startTime;
+      console.log(`✗ Test ${testNumber} FAILED - Connection error after ${elapsed}ms`);
+      console.log(`Error: ${error.message}`);
+      resolve({ success: false, error: error.message, time: elapsed });
+    });
+    
+    req.write(data);
+    req.end();
+  });
+}
+
+// Run stress test
+async function runStressTest() {
+  console.log('Starting stress test for Gemma-3-12b on localhost:1234');
+  console.log('Testing word selection for cloze reader game...\n');
+  
+  const results = [];
+  
+  // Test each passage
+  for (let i = 0; i < testPassages.length; i++) {
+    const result = await testLLMConnection(testPassages[i], i + 1);
+    results.push(result);
+    
+    // Small delay between tests
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+  
+  // Summary
+  console.log('\n=== STRESS TEST SUMMARY ===');
+  const successful = results.filter(r => r.success).length;
+  const failed = results.length - successful;
+  const avgTime = results.reduce((sum, r) => sum + r.time, 0) / results.length;
+  
+  console.log(`Total tests: ${results.length}`);
+  console.log(`Successful: ${successful}`);
+  console.log(`Failed: ${failed}`);
+  console.log(`Average response time: ${avgTime.toFixed(0)}ms`);
+  console.log(`Success rate: ${(successful / results.length * 100).toFixed(1)}%`);
+  
+  if (successful === results.length) {
+    console.log('\n✓ All tests passed! The Gemma-3-12b server is functioning correctly for cloze reader.');
+  } else if (successful > 0) {
+    console.log('\n⚠ Some tests passed. The server is partially functional.');
+  } else {
+    console.log('\n✗ All tests failed. Please check if the server is running on port 1234.');
+  }
+}
+
+// Run the test
+runStressTest().catch(console.error);

test-prompts-lm-studio.md

@@ -0,0 +1,262 @@
+# Gemma-3-27b Model Integration Guide for Cloze Reader
+
+## Part 1: Step-by-Step API Request Processing
+
+### 1. Initial Request Reception
+When the Cloze Reader application makes an API request through OpenRouter:
+
+1. **Authentication**: Verify Bearer token from `Authorization` header
+2. **Request Type Detection**: Identify the operation type based on prompt content
+3. **Parameter Extraction**: Parse temperature, max_tokens, and message content
+4. **Rate Limiting Check**: Ensure request complies with free tier limits
+
+### 2. Word Selection Request Processing
+
+**When Temperature = 0.3 and prompt contains "CLOZE DELETION PRINCIPLES":**
+
+1. **Parse Passage**: Extract the text passage from the system message
+2. **Identify Difficulty Level**: 
+   - Level 1-2: Target 4-7 letter words (easy vocabulary)
+   - Level 3-4: Target 4-10 letter words (medium difficulty)
+   - Level 5+: Target 5-14 letter words (challenging vocabulary)
+3. **Select Words**:
+   - Identify significant vocabulary words (nouns, verbs, adjectives, adverbs)
+   - Avoid proper nouns, numbers, articles, and function words
+   - Ensure words are contextually important for comprehension
+4. **Format Response**: Return JSON array of selected words
+5. **Validate**: Ensure all words exist in the original passage
+
+### 3. Batch Processing Request
+
+**When Temperature = 0.5 and prompt contains two passages:**
+
+1. **Parse Both Passages**: Extract passage1 and passage2 from the prompt
+2. **Process Each Passage**:
+   - Apply word selection logic for each based on difficulty level
+   - Generate one-sentence contextualization for each book
+3. **Format Response**: Return structured JSON with both passages' data
+4. **Ensure Consistency**: Words must match exactly as they appear in passages
+
+### 4. Contextualization Request
+
+**When Temperature = 0.2 and prompt asks for book context:**
+
+1. **Extract Book Information**: Parse title and author from prompt
+2. **Generate Context**: Create one factual sentence about:
+   - Type of work (novel, short story, essay)
+   - Historical period when written
+   - Literary significance or genre
+3. **Keep Concise**: Limit to 80 tokens maximum
+4. **Avoid Speculation**: Only include verifiable information
+
+### 5. Chat Hint Request
+
+**When Temperature = 0.6 and prompt includes "word puzzles":**
+
+1. **Identify Question Type**:
+   - `part_of_speech`: Grammar category identification
+   - `sentence_role`: Function in the sentence
+   - `word_category`: Abstract/concrete classification
+   - `synonym`: Alternative word suggestion
+2. **Parse Target Word**: Extract the hidden word (NEVER reveal it)
+3. **Generate Appropriate Hint**:
+   - Follow exact format requested
+   - Stay within 50 token limit
+   - Use plain text only, no formatting
+4. **Validate**: Ensure hint doesn't contain or spell out the target word
+
+### 6. Response Formatting Rules
+
+1. **JSON Responses**: 
+   - Word selection: Clean array format `["word1", "word2"]`
+   - Batch processing: Nested object structure
+   - No markdown code blocks unless specifically requested
+
+2. **Text Responses**:
+   - Contextualization: Single sentence, no formatting
+   - Chat hints: Plain text, follows exact format requested
+
+3. **Error Handling**:
+   - Invalid requests: Return graceful error messages
+   - Missing parameters: Use sensible defaults
+   - Malformed input: Attempt to parse intent
+
+## Part 2: LM Studio Testing Configuration
+
+### System Prompt
+```
+You are a specialized AI assistant for the Cloze Reader educational application. You help create vocabulary exercises by selecting appropriate words from text passages and providing contextual hints without revealing answers. Always respond in the exact format requested, using plain JSON or text as specified. Never use markdown formatting unless explicitly requested.
+```
+
+### Temperature Settings
+- **Word Selection**: 0.3
+- **Batch Processing**: 0.5
+- **Contextualization**: 0.2
+- **Chat Hints**: 0.6
+
+### Response Length Limits
+- **Word Selection**: 100 tokens
+- **Batch Processing**: 800 tokens
+- **Contextualization**: 80 tokens
+- **Chat Hints**: 50 tokens
+
+### Test Prompts
+
+#### 1. Word Selection Test (Level 1-2 Easy)
+```json
+{
+  "messages": [
+    {
+      "role": "system",
+      "content": "CLOZE DELETION PRINCIPLES:\n- Select words that require understanding context and vocabulary to identify\n- Choose words essential for comprehension that test language ability\n- Target words where deletion creates meaningful cognitive gaps\n\nFrom the following passage, select exactly 1 word that is important for reading comprehension.\n\nDifficulty level 1-2: Focus on easier vocabulary (4-7 letters) like common nouns, simple verbs, and basic adjectives.\n\nRETURN ONLY A JSON ARRAY OF YOUR SELECTED WORDS. Select words that appear EXACTLY as written in the passage.\n\nPassage:\nThe old woman lived in a small cottage by the forest. Every morning, she would walk to the village market to buy fresh bread."
+    }
+  ],
+  "temperature": 0.3,
+  "max_tokens": 100
+}
+```
+
+**Expected Output Schema:**
+```json
+{
+  "type": "array",
+  "items": {
+    "type": "string",
+    "minLength": 4,
+    "maxLength": 7
+  },
+  "minItems": 1,
+  "maxItems": 1
+}
+```
+
+#### 2. Batch Processing Test (Level 3-4 Medium)
+```json
+{
+  "messages": [
+    {
+      "role": "system",
+      "content": "Process these two passages for a cloze reading exercise:\n\nPASSAGE 1 (Pride and Prejudice by Jane Austen):\nIt is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want of a wife.\n\nPASSAGE 2 (A Tale of Two Cities by Charles Dickens):\nIt was the best of times, it was the worst of times, it was the age of wisdom, it was the age of foolishness.\n\nFor each passage:\n1. Select 1 word for difficulty level 3-4 (medium vocabulary, 4-10 letters)\n2. Write ONE sentence about the book/author\n\nReturn a JSON object with this structure:\n{\n  \"passage1\": {\n    \"words\": [selected words],\n    \"context\": \"One sentence about the book\"\n  },\n  \"passage2\": {\n    \"words\": [selected words],\n    \"context\": \"One sentence about the book\"\n  }\n}"
+    }
+  ],
+  "temperature": 0.5,
+  "max_tokens": 800
+}
+```
+
+**Expected Output Schema:**
+```json
+{
+  "type": "object",
+  "properties": {
+    "passage1": {
+      "type": "object",
+      "properties": {
+        "words": {
+          "type": "array",
+          "items": { "type": "string" },
+          "minItems": 1,
+          "maxItems": 1
+        },
+        "context": {
+          "type": "string",
+          "maxLength": 150
+        }
+      },
+      "required": ["words", "context"]
+    },
+    "passage2": {
+      "type": "object",
+      "properties": {
+        "words": {
+          "type": "array",
+          "items": { "type": "string" },
+          "minItems": 1,
+          "maxItems": 1
+        },
+        "context": {
+          "type": "string",
+          "maxLength": 150
+        }
+      },
+      "required": ["words", "context"]
+    }
+  },
+  "required": ["passage1", "passage2"]
+}
+```
+
+#### 3. Contextualization Test
+```json
+{
+  "messages": [
+    {
+      "role": "user",
+      "content": "Write one factual sentence about 'The Adventures of Sherlock Holmes' by Arthur Conan Doyle. Focus on what type of work it is, when it was written, or its historical significance. Keep it under 20 words and conversational."
+    }
+  ],
+  "temperature": 0.2,
+  "max_tokens": 80
+}
+```
+
+**Expected Output:** Plain text string, no JSON structure required.
+
+#### 4. Chat Hint Test (Part of Speech)
+```json
+{
+  "messages": [
+    {
+      "role": "system",
+      "content": "You provide clues for word puzzles. You will be told the target word that players need to guess, but you must NEVER mention, spell, or reveal that word in your response. Follow the EXACT format requested. Be concise and direct about the target word without revealing it. Use plain text only - no bold, italics, asterisks, or markdown formatting. Stick to word limits."
+    },
+    {
+      "role": "user",
+      "content": "The target word is 'walked'. The sentence is: 'Every morning, she would _____ to the village market to buy fresh bread.'\n\nQuestion type: part_of_speech\n\nIdentify what part of speech fits in this blank. Answer in 2-5 words. Format: 'It's a/an [part of speech]'"
+    }
+  ],
+  "temperature": 0.6,
+  "max_tokens": 50
+}
+```
+
+**Expected Output:** Plain text following format "It's a/an [part of speech]"
+
+#### 5. Chat Hint Test (Synonym)
+```json
+{
+  "messages": [
+    {
+      "role": "system",
+      "content": "You provide clues for word puzzles. You will be told the target word that players need to guess, but you must NEVER mention, spell, or reveal that word in your response. Follow the EXACT format requested. Be concise and direct about the target word without revealing it. Use plain text only - no bold, italics, asterisks, or markdown formatting. Stick to word limits."
+    },
+    {
+      "role": "user",
+      "content": "The target word is 'cottage'. The sentence is: 'The old woman lived in a small _____ by the forest.'\n\nQuestion type: synonym\n\nSuggest a different word that could replace the blank. Answer in 1-3 words only."
+    }
+  ],
+  "temperature": 0.6,
+  "max_tokens": 50
+}
+```
+
+**Expected Output:** Plain text with 1-3 word synonym
+
+### LM Studio Configuration
+
+1. **Model Selection**: Load gemma-3-27b or equivalent model
+2. **Context Length**: Set to at least 4096 tokens
+3. **GPU Layers**: Maximize based on available VRAM
+4. **Batch Size**: 512 for optimal performance
+5. **Prompt Format**: Use ChatML or model's native format
+
+### Testing Checklist
+
+- [ ] Verify JSON responses are clean (no markdown blocks)
+- [ ] Check word selections match passage exactly
+- [ ] Ensure hints never reveal target words
+- [ ] Validate response stays within token limits
+- [ ] Test difficulty level word length constraints
+- [ ] Confirm batch processing handles both passages
+- [ ] Verify contextualization produces factual content
+- [ ] Test all four hint question types