src/Tool.py

from langchain.tools import tool
from config import *
@tool
def search_tool(query: str) -> str:
    """

    Search for current, real-world information on any topic.



    Use this for:

    - Recent developments, news, or updates

    - Verifying facts that may have changed

    - Finding real examples, libraries, or frameworks



    Do NOT use for timeless concepts (e.g., 'what is a variable') —

    answer those directly from knowledge.



    Args:

        query: A specific, focused search query (3-8 words ideal)

    """
    result = tavily_client.search(query)
    return str(result.get("results", result))


@tool
def simplify_explanation(concept: str, student_level: str) -> str:
    """

    Simplify a complex concept into a beginner-friendly explanation.



    Use when the student is confused or explicitly asks for a simpler version.



    Args:

        concept: The specific concept to simplify

        student_level: 'beginner', 'intermediate', or 'advanced'



    Returns:

        Plain-language explanation with analogy and concrete example

    """
    return (
        f"Simplified explanation of '{concept}' for {student_level} level:\n"
        f"[Analogy] + [Plain-language breakdown] + [Concrete example]"
    )


@tool
def generate_examples(concept: str, example_type: str, student_level: str) -> str:
    """

    Generate targeted examples to reinforce understanding of a concept.



    Use after explaining a concept to make it concrete.



    Args:

        concept: The topic to generate examples for

        example_type: 'real-world', 'code', 'analogy', or 'all'

        student_level: 'beginner', 'intermediate', or 'advanced'



    Returns:

        2-3 examples matched to the student's level and requested type

    """
    return (
        f"{example_type} examples for '{concept}' ({student_level} level):\n"
        f"1. Real-world scenario\n2. Simple analogy\n3. Code example (if applicable)"
    )


@tool
def create_quiz(concept: str, difficulty: str, num_questions: int) -> str:
    """

    Create a multiple-choice quiz to test understanding of a concept.



    Use after teaching a concept to verify retention before moving on.



    Args:

        concept: The topic to quiz on

        difficulty: 'easy', 'medium', or 'hard'

        num_questions: Number of questions (1-5 recommended)



    Returns:

        MCQ quiz with answer key — present questions one at a time

        after end of session create final quiz using composio_tools

    """
    return f"""

Quiz on '{concept}' ({difficulty}, {num_questions} questions):



Q1. [Question about {concept}]?

A) Option A

B) Option B

C) Option C  ← correct

D) Option D



[Answer Key: hidden until student answers]

"""


@tool
def evaluate_answer(

    student_answer: str,

    correct_answer: str,

    concept: str

) -> str:
    """

    Evaluate a student's answer and provide constructive feedback.



    Use immediately after the student responds to a quiz question.



    Args:

        student_answer: What the student submitted

        correct_answer: The expected correct answer

        concept: The concept being tested (for targeted feedback)



    Returns:

        Pass/fail verdict + explanation of why + hint if wrong

    """
    if student_answer.strip().lower() == correct_answer.strip().lower():
        return f"✅ Correct! You've understood '{concept}' well."
    return (
        f"❌ Not quite. The correct answer is '{correct_answer}'.\n"
        f"Hint: Review the core idea of '{concept}' — "
        f"focus on [key principle]. Try once more?"
    )


@tool
def summarize_content(text: str, focus: str) -> str:
    """

    Summarize a block of content with a specific focus area.



    Use when the student asks for a recap or before ending a session.



    Args:

        text: The content to summarize

        focus: What aspect to emphasize (e.g., 'key concepts', 'steps', 'formulas')



    Returns:

        Concise summary with key takeaways and further reading links

    """
    return (
        f"Summary (focus: {focus}):\n"
        f"{text[:300]}...\n\n"
        f"Key Takeaways:\n- [Point 1]\n- [Point 2]\n- [Point 3]\n\n"
        f"Further Reading: [relevant links]"
    )


@tool
def generate_exercise(topic: str) -> str:
    """Generate structured exercises"""
    return f"""

[EXERCISE PLAN: {topic}]



1. Basic:

- Explain {topic} in your own words



2. Applied:

- Give a real-world example of {topic}



3. Challenge:

- Solve a problem using {topic}

"""

@tool
def case_study(topic: str) -> str:
    """Generate case study"""
    return f"""

[CASE STUDY: {topic}]



- Context: Real-world use of {topic}

- Problem: What challenge is solved?

- Analysis: How {topic} is applied

"""

@tool
def role_play(topic: str) -> str:
    """Generate role-play scenario"""
    return f"""

[ROLE PLAY: {topic}]



You are in a real-world situation using {topic}.



Task:

- Identify problem

- Apply concept

- Explain your decision

"""

@tool
def evaluate_response(answer: str) -> str:
    """Evaluate student answer"""
    return f"""

[FEEDBACK]



Answer:

{answer}



- Understanding: Weak / Medium / Strong

- Missing points: ...

- Improvement: Refine your reasoning + add examples

"""

@tool
def search_tool(query: str) -> str:
    """

    Search for current, real-world information on any topic.



    Use this for:

    - Recent developments, news, or updates

    - Verifying facts that may have changed

    - Finding real examples, libraries, or frameworks



    Do NOT use for timeless concepts (e.g., 'what is a variable') —

    answer those directly from knowledge.



    Args:

        query: A specific, focused search query (3-8 words ideal)

    """
    return tavily_client.search(query)
@tool
def create_learning_plan(topic: str, level: str) -> str:
    """

    Creates a structured, dependency-aware learning roadmap.



    Args:

        topic: The subject the student wants to learn

        level: Student's current level — 'beginner', 'intermediate', or 'advanced'



    Returns:

        Ordered steps with goals, durations, prerequisites, and success criteria

    """
    return f"Roadmap for '{topic}' at {level} level"


@tool
def define_milestones(topic: str, level: str) -> str:
    """

    Defines measurable milestones and checkpoints for a learning plan.



    Args:

        topic: The subject being learned

        level: Student's current level



    Returns:

        Milestone list with unlock conditions and success criteria

    """
    return f"Milestones for '{topic}' at {level} level"


@tool
def assign_practice(topic: str, step: str, difficulty: str) -> str:
    """

    Assigns hands-on exercises for a specific step in the learning plan.



    Args:

        topic: Main subject

        step: Specific concept the student just studied

        difficulty: 'easy', 'medium', or 'hard' — must match student level



    Returns:

        Practice task with description, expected output, and success condition

    """
    return f"{difficulty} practice task for '{step}' in '{topic}'"


@tool
def evaluate_progress(topic: str, step: str, student_response: str) -> str:
    """

    Evaluates student performance at a checkpoint and recommends next action.



    Args:

        topic: Main subject

        step: Concept being evaluated

        student_response: Student's answer or submitted work



    Returns:

        Score (0-100), detected weak points, and next action:

        'advance' | 'reinforce' | 'simplify'

    """
    return f"Evaluation for '{step}' in '{topic}': {student_response}"


@tool
def adjust_learning_path(current_plan: str, feedback: str, score: int) -> str:
    """

    Dynamically adjusts the learning roadmap based on performance signals.



    Args:

        current_plan: The active roadmap (text or JSON)

        feedback: Notes on student struggles or strengths

        score: Latest checkpoint score (0-100)



    Returns:

        Updated roadmap with a change log explaining what was modified and why

    """
    return f"Adjusted plan (score={score}) based on: {feedback}"