AI Tutoring

// From server/services/enhanced-lesson-service.ts:233
const structureResponse = await askOpenRouter({
  messages: [
    {
      role: 'system',
      content: buildEnhancedLessonPrompt(gradeLevel, topic, subject)
    },
    {
      role: 'user',
      content: `Create an educational lesson about "${topic}" for grade ${gradeLevel} students.`
    }
  ],
  model: 'google/gemini-2.0-flash-001',
  temperature: 0.7,
});

// From server/prompts/grades/grade34.ts:8
- Maximum 8 words per sentence
- Maximum 200 words total
- Use grade 3-4 vocabulary ONLY
- Introduce ONE new concept at a time
- Connect to experiences familiar to 8-10 year olds

// From server/prompts/grades/grade56.ts:8
- Maximum 12 words per sentence average
- Maximum 400 words total
- Introduce academic vocabulary with context
- Build conceptual understanding
- Include cause-effect relationships

// From server/prompts/grades/grade78.ts:8
- Complex sentence structures acceptable
- Maximum 700 words total
- Use subject-specific terminology
- Develop multi-step reasoning
- Include interdisciplinary connections

// From server/prompts/grades/grade9Plus.ts:8
- No sentence structure limitations
- 1000-2000 words as appropriate
- Full technical vocabulary expected
- Complex theoretical frameworks
- Research-level thinking

// From server/services/enhanced-lesson-service.ts:95
function getWordLimits(gradeLevel: number) {
  if (gradeLevel <= 2) return { 
    total: 75, introduction: 15, key_concepts: 20, 
    examples: 20, practice: 15, summary: 5, sentenceMax: 5 
  };
  if (gradeLevel <= 4) return { 
    total: 200, introduction: 30, key_concepts: 70, 
    examples: 50, practice: 35, summary: 15, sentenceMax: 8 
  };
  if (gradeLevel <= 6) return { 
    total: 400, introduction: 60, key_concepts: 160, 
    examples: 100, practice: 60, summary: 20, sentenceMax: 12 
  };
  if (gradeLevel <= 8) return { 
    total: 700, introduction: 100, key_concepts: 280, 
    examples: 170, practice: 100, summary: 50, sentenceMax: 18 
  };
  return { 
    total: 1200, introduction: 150, key_concepts: 500, 
    examples: 300, practice: 150, summary: 100, sentenceMax: 25 
  };
}

// From server/services/enhanced-lesson-service.ts:446
export async function generateLessonWithRetry(
  gradeLevel: number,
  topic: string,
  options = {}
): Promise<EnhancedLessonSpec> {
  const maxRetries = 3;
  let lastError: Error | undefined;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const spec = await generateEnhancedLesson(
        gradeLevel, topic, withImages, subject, difficulty
      );
      
      // Validate the spec — throws if invalid
      validateLessonSpec(spec);
      
      return spec;
    } catch (err) {
      lastError = err;
      console.warn(`Attempt ${attempt}/${maxRetries} failed: ${err.message}`);
    }
  }
  
  throw new Error(`Lesson generation failed after ${maxRetries} attempts`);
}

// From server/services/enhanced-lesson-service.ts:497
export async function generateEnhancedQuestions(
  enhancedLesson: EnhancedLessonSpec,
  questionCount: number = 5
): Promise<any[]> {
  const lessonContent = enhancedLesson.sections
    .map(s => `${s.title}:\n${s.content}`)
    .join('\n\n');

  const response = await askOpenRouter({
    messages: [
      {
        role: 'system',
        content: `Create ${questionCount} multiple-choice questions. 
                  Each must have exactly 4 answer options with one correct answer.`
      },
      {
        role: 'user',
        content: `Create questions for grade ${enhancedLesson.targetGradeLevel} 
                  lesson "${enhancedLesson.title}".\n\nLesson content:\n${lessonContent}`
      }
    ],
    model: 'google/gemini-2.0-flash-001',
    temperature: 0.7,
  });
  
  return parseAndValidateQuestions(response);
}