added generator test

run.sh

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# run.sh — friendly wrapper for running the distillation pipeline
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$ROOT"
+
+# -----------------------------
+# Default config (can be overridden in env or CLI)
+# -----------------------------
+ES_NODE="${ES_NODE:-http://localhost:9200}"
+ES_INDEX="${ES_INDEX:-quo_distill_index}"
+
+PIPELINE_SEED_MODE="${PIPELINE_SEED_MODE:-question-first}"
+
+RETRIEVAL_MODE="${RETRIEVAL_MODE:-hybrid}"
+RETRIEVAL_K="${RETRIEVAL_K:-6}"
+
+QUESTION_MAX="${QUESTION_MAX:-3}"
+LIMIT="${LIMIT:-5}"
+
+GENERATOR_MODEL="${GENERATOR_MODEL:-qwen3-vl:8b-thinking}"
+VERIFIER_MODEL="${VERIFIER_MODEL:-tensortemplar/patronus-lynx:8b-instruct-q4_K_M}"
+REWARD_MODEL="${REWARD_MODEL:-tensortemplar/patronus-lynx:8b-instruct-q4_K_M}"
+
+VERBOSE=0
+THINKING=0
+
+# -----------------------------
+# Argument parsing
+# -----------------------------
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -l|--limit)
+      LIMIT="$2"
+      shift 2
+      ;;
+    -q|--questions)
+      QUESTION_MAX="$2"
+      shift 2
+      ;;
+    -v|--verbose)
+      VERBOSE=1
+      shift
+      ;;
+    -t|--thinking)
+      THINKING=1
+      shift
+      ;;
+    *)
+      echo "Unknown option: $1"
+      echo "Usage: ./run.sh [--limit N] [--questions N] [--verbose] [--thinking]"
+      exit 1
+      ;;
+  esac
+done
+
+# If thinking flag is present, use thinking model + thinking prompt header
+if [[ "$THINKING" -eq 1 ]]; then
+  echo "🧠 Using THINKING MODE"
+  GENERATOR_MODEL="qwen3-vl:8b-thinking"
+fi
+
+# -----------------------------
+# Export for pipeline
+# -----------------------------
+export ES_NODE
+export ES_INDEX
+export PIPELINE_SEED_MODE
+
+export RETRIEVAL_MODE
+export RETRIEVAL_K
+
+export QUESTION_MAX
+export LIMIT
+
+export GENERATOR_PROVIDER="ollama"
+export GENERATOR_MODEL
+
+export VERIFIER_PROVIDER="ollama"
+export VERIFIER_MODEL
+
+export REWARD_PROVIDER="ollama"
+export REWARD_MODEL
+
+echo "========================================"
+echo "🚀 Running Distillation Pipeline"
+echo " ES_NODE:          $ES_NODE"
+echo " ES_INDEX:         $ES_INDEX"
+echo " Retrieval:        $RETRIEVAL_MODE (k=$RETRIEVAL_K)"
+echo " Mode:             $PIPELINE_SEED_MODE"
+echo " Limit:            $LIMIT"
+echo " Question max:     $QUESTION_MAX"
+echo " Generator model:  $GENERATOR_MODEL"
+echo " Verifier model:   $VERIFIER_MODEL"
+echo " Reward model:     $REWARD_MODEL"
+echo " Verbose:          $VERBOSE"
+echo "========================================"
+echo
+
+if [[ "$VERBOSE" -eq 1 ]]; then
+  npm run pipeline -- --limit "$LIMIT" --verbose
+else
+  npm run pipeline -- --limit "$LIMIT"
+fi

run_qg_verbose.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-
-# Always fail on error
-set -e
-
-echo "==============================================="
-echo " Running Question-First Distillation Pipeline"
-echo "==============================================="
-echo
-
-# You can adjust limit here if needed
-LIMIT="${1:-5}"
-
-export PIPELINE_SEED_MODE=question-first
-
-echo "→ Mode:            question-first"
-echo "→ Verbose:         yes"
-echo "→ Limit:           $LIMIT"
-echo
-
-npm run pipeline -- --limit "$LIMIT" --verbose

src/generator/generator_core.mjs

@@ -2,80 +2,45 @@
 import fs from 'fs/promises';
 import path from 'path';
 
-// Loads generator prompt template
-async function loadPromptTemplate() {
+// Load generator template
+async function loadTemplate() {
   const filePath = path.resolve(
     path.dirname(new URL(import.meta.url).pathname),
-    '..',
-    '..',
-    'prompts',
-    'generator_prompt.txt'
+    '..', '..', 'prompts', 'generator_prompt.txt'
   );
   return await fs.readFile(filePath, 'utf8');
 }
 
-/**
- * Build the full prompt from template, question, and context chunks.
- */
-async function makeGeneratorPrompt(question, contextChunks) {
-  const tmpl = await loadPromptTemplate();
-
-  let prompt = tmpl.replace(/{{QUESTION}}/g, question);
-
-  if (tmpl.includes('{{CONTEXT}}')) {
-    const contextText =
-      contextChunks?.map((c) => c.content || c.text || '').join('\n\n---\n\n') ??
-      '';
-
-    prompt = prompt.replace(/{{CONTEXT}}/g, contextText);
-  }
+export async function runGenerator(question, contextChunks, provider) {
+  const template = await loadTemplate();
 
-  return prompt;
-}
+  const ctxText = contextChunks
+    .map(c => c.content || c.text || "")
+    .join("\n\n---\n\n");
 
-/**
- * runGenerator
- *
- * @param {string} question        - the natural language question
- * @param {Array}  contextChunks   - retrieved context objects from RAG
- * @param {object} provider        - { generate(prompt) → string }
- * @returns {object} generator result:
- *   {
- *     raw: string,          // full model output (think + answer)
- *     thought: string|null, // content inside <think>...</think> if present
- *     answer: string,       // final answer after </think> (or whole raw if no tags)
- *     query: string,        // original question
- *     context: Array        // original context chunks
- *   }
- */
-export async function runGenerator(question, contextChunks, provider) {
-  const prompt = await makeGeneratorPrompt(question, contextChunks);
+  const prompt = template
+    .replace('{{QUESTION}}', question)
+    .replace('{{CONTEXT}}', ctxText);
 
   const raw = await provider.generate(prompt);
 
-  let thought = null;
-  let answer = raw?.trim() ?? '';
-
-  // Extract <think> ... </think> if the thinking model emits it
-  const startTag = '<think>';
-  const endTag = '</think>';
-  const startIdx = raw.indexOf(startTag);
-  const endIdx = raw.indexOf(endTag);
+  // extract visible chain-of-thought
+  const thinkMatch = raw.match(/<think>([\s\S]*?)<\/think>/i);
+  const thought = thinkMatch ? thinkMatch[1].trim() : null;
 
-  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
-    thought = raw.slice(startIdx + startTag.length, endIdx).trim();
-    answer = raw.slice(endIdx + endTag.length).trim();
+  // final answer = text after </think>
+  let answer = raw;
+  if (thinkMatch) {
+    answer = raw.slice(thinkMatch.index + thinkMatch[0].length).trim();
   }
 
   return {
     raw,
     thought,
     answer,
-    query: question,
-    context: contextChunks || [],
+    question,
+    context: contextChunks
   };
 }
 
-export default {
-  runGenerator,
-};
+export default { runGenerator };

tests/generator_core.test.mjs

@@ -1,8 +1,8 @@
 import { describe, it, expect, vi } from 'vitest';
 import { runGenerator } from '../src/generator/generator_core.mjs';
 
-describe('generator_core.mjs', () => {
-  it('builds prompt and returns a plain-text answer', async () => {
+describe('generator_core.mjs (thinking generator)', () => {
+  it('includes question and context in the prompt', async () => {
     const fakeContext = [
       { content: 'First context chunk' },
       { content: 'Second context chunk' },
@@ -10,31 +10,76 @@ describe('generator_core.mjs', () => {
 
     const provider = {
       generate: vi.fn(async (prompt) => {
-        // At minimum, prompt should contain the question
+        // Prompt should contain the question
         expect(prompt).toContain('What is love?');
-        // We *don’t* assume the template includes the raw context text,
-        // since the current generator_prompt.txt may only use {{QUESTION}}.
-        return 'Because love is all that there is';
+        // And the context chunks (we expect {{CONTEXT}} is wired up)
+        expect(prompt).toContain('First context chunk');
+        expect(prompt).toContain('Second context chunk');
+
+        // Return some simple thinking-style output
+        return `<think>
+I consider the meaning of love using only the context.
+</think>
+Love is the recognition of shared being.
+`;
       }),
     };
 
     const result = await runGenerator('What is love?', fakeContext, provider);
 
     expect(provider.generate).toHaveBeenCalledOnce();
-    expect(result.raw).toBe('Because love is all that there is');
-    expect(result.answer).toBe('Because love is all that there is');
+    expect(result.question).toBe('What is love?');
+    expect(result.context).toHaveLength(2);
+    expect(result.raw).toContain('<think>');
+    expect(result.answer).toBe('Love is the recognition of shared being.');
+    expect(result.thought).toContain('consider the meaning of love');
+  });
+
+  it('extracts thought and answer correctly when <think> block is present', async () => {
+    const fakeContext = [{ content: 'ctx' }];
+
+    const provider = {
+      generate: vi.fn(async () => {
+        return `<think>
+Step 1: Read the context carefully.
+Step 2: Identify the relevant statements.
+Step 3: Synthesize an answer.
+</think>
+The final answer derived from the context.`;
+      }),
+    };
+
+    const result = await runGenerator(
+      'Test question?',
+      fakeContext,
+      provider,
+    );
+
+    expect(result.raw).toContain('<think>');
+    expect(result.thought).toContain('Step 1:');
+    expect(result.thought).toContain('Step 3:');
+    expect(result.answer).toBe('The final answer derived from the context.');
   });
 
-  it('handles arbitrary non-JSON output without error', async () => {
-    const fakeContext = [{ content: 'chunk' }];
+  it('handles output without <think> block gracefully', async () => {
+    const fakeContext = [{ content: 'ctx' }];
 
     const provider = {
-      generate: vi.fn(async () => 'this is not JSON and that is fine'),
+      generate: vi.fn(async () => {
+        // No <think> tags at all
+        return 'Just a direct answer with no visible reasoning.';
+      }),
     };
 
-    const result = await runGenerator('broken?', fakeContext, provider);
+    const result = await runGenerator(
+      'Another question?',
+      fakeContext,
+      provider,
+    );
 
-    expect(result.raw).toBe('this is not JSON and that is fine');
-    expect(result.answer).toBe('this is not JSON and that is fine');
+    expect(result.raw).toBe('Just a direct answer with no visible reasoning.');
+    // No think tags means thought=null and answer = full output
+    expect(result.thought).toBeNull();
+    expect(result.answer).toBe('Just a direct answer with no visible reasoning.');
   });
 });