Grading agent

async function gradeOpenEnded(
  question: Question,
  answer: Answer
): Promise<GradingResult> {
  const systemPrompt = `
    You are an expert grader evaluating a student's answer.
    
    Question: ${question.prompt}
    
    Correct answer: ${question.correctAnswer}
    
    Grading rubric:
    ${JSON.stringify(question.gradingRubric, null, 2)}
    
    Student answer: ${answer.answerText}
    
    Evaluate the answer:
    1. Is it correct? (true/false)
    2. Score from 0.0 to 1.0
    3. Detailed feedback (2-3 sentences)
    4. Identified misconceptions (if any)
  `;
  
  const response = await anthropic.messages.create({
    model: "claude-opus-4-20250514",
    max_tokens: 2000,
    system: systemPrompt,
    messages: [{
      role: "user",
      content: "Grade this answer."
    }]
  });
  
  // Parse Claude's response
  const result = parseGradingResponse(response.content[0].text);
  
  return result;
}

{
  "type": "key_points",
  "points": [
    "Binary search tree maintains sorted order",
    "Left subtree contains smaller values",
    "Right subtree contains larger values",
    "Property applies recursively to all subtrees"
  ],
  "scoring": {
    "all_points": 1.0,
    "most_points": 0.75,
    "some_points": 0.5,
    "few_points": 0.25,
    "no_points": 0.0
  },
  "min_points_for_passing": 3
}

{
  "type": "comparative",
  "reference_answer": "In-order traversal visits nodes in sorted order: left subtree, root, right subtree. Pre-order visits root first, then left, then right.",
  "required_elements": [
    "in-order produces sorted sequence",
    "pre-order visits root first"
  ],
  "scoring": {
    "excellent": { "threshold": 0.9, "score": 1.0 },
    "good": { "threshold": 0.7, "score": 0.85 },
    "acceptable": { "threshold": 0.5, "score": 0.7 },
    "poor": { "threshold": 0.3, "score": 0.5 },
    "failing": { "threshold": 0.0, "score": 0.0 }
  }
}

{
  "type": "code_execution",
  "language": "python",
  "test_cases": [
    {
      "input": "search(tree, 5)",
      "expected_output": "True",
      "weight": 0.2
    },
    {
      "input": "search(tree, 7)",
      "expected_output": "False",
      "weight": 0.2
    },
    {
      "input": "search(None, 5)",
      "expected_output": "False",
      "weight": 0.3,
      "description": "Edge case: empty tree"
    },
    {
      "input": "search(single_node, 1)",
      "expected_output": "True",
      "weight": 0.3,
      "description": "Edge case: single node"
    }
  ],
  "code_quality_weight": 0.2
}

{
  "isCorrect": true,
  "score": 1.0,
  "feedback": "Excellent! You correctly identified that in-order traversal produces a sorted sequence. Your explanation of the recursive process was clear and accurate."
}

{
  "isCorrect": false,
  "score": 0.6,
  "feedback": "You're on the right track. You correctly mentioned that the left subtree contains smaller values, but you missed that the right subtree contains larger values. Also, remember that this property applies recursively to all subtrees, not just the root's children.",
  "misconceptions": [
    "Thinks BST property only applies to root level"
  ]
}

{
  "isCorrect": false,
  "score": 0.0,
  "feedback": "This isn't correct. A binary search tree has a specific ordering property: for every node, all values in the left subtree are smaller, and all values in the right subtree are larger. Review the BST properties and try again.",
  "misconceptions": [
    "Confuses BST with general binary tree",
    "Doesn't understand sorted order property"
  ],
  "suggested_review": ["BST Properties", "Tree Ordering"]
}

async function gradeAllDiagnostics(
  conceptNodeId: string,
  userId: string
): Promise<GradingSummary> {
  // Load questions and answers
  const assessment = await db.query.assessments.findFirst({
    where: and(
      eq(assessments.targetNodeId, conceptNodeId),
      eq(assessments.userId, userId)
    ),
    with: {
      questions: true
    }
  });
  
  const answers = await db.query.answers.findMany({
    where: eq(answers.assessmentId, assessment.id)
  });
  
  // Grade each answer
  const gradingResults = await Promise.all(
    answers.map(async (answer) => {
      const question = assessment.questions.find(q => q.id === answer.questionId);
      
      if (question.format === "mcq") {
        return gradeMCQ(question, answer);
      } else {
        return await gradeOpenEnded(question, answer);
      }
    })
  );
  
  // Update database with grades
  await db.transaction(async (tx) => {
    for (let i = 0; i < answers.length; i++) {
      await tx.update(answers)
        .set({
          isCorrect: gradingResults[i].isCorrect,
          score: gradingResults[i].score,
          feedback: gradingResults[i].feedback
        })
        .where(eq(answers.id, answers[i].id));
    }
  });
  
  // Generate summary
  const summary = {
    total_questions: answers.length,
    correct: gradingResults.filter(r => r.isCorrect).length,
    incorrect: gradingResults.filter(r => !r.isCorrect).length,
    average_score: average(gradingResults.map(r => r.score)),
    weak_areas: identifyWeakAreas(gradingResults, assessment.questions),
    strong_areas: identifyStrongAreas(gradingResults, assessment.questions),
    misconceptions: gradingResults
      .flatMap(r => r.misconceptions || [])
      .filter((m, i, arr) => arr.indexOf(m) === i) // unique
  };
  
  return summary;
}

POST /api/agents/concepts/:conceptNodeId/run