massgen 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

massgen/tool/_extraframework_agents/langgraph_lesson_planner_tool.py

@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+"""
+LangGraph Lesson Planner Tool
+This tool demonstrates interoperability by wrapping LangGraph's state graph functionality as a MassGen custom tool.
+"""
+
+import operator
+import os
+from typing import Annotated, Any, AsyncGenerator, Dict, List, Sequence, TypedDict
+
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from langgraph.graph import END, StateGraph
+
+from massgen.tool import context_params
+from massgen.tool._result import ExecutionResult, TextContent
+
+
+class LessonPlannerState(TypedDict):
+    """State for the lesson planner workflow."""
+
+    messages: Annotated[Sequence[BaseMessage], operator.add]
+    user_prompt: str
+    context: str
+    standards: str
+    lesson_plan: str
+    reviewed_plan: str
+    final_plan: str
+
+
+async def run_langgraph_lesson_planner_agent(
+    messages: List[Dict[str, Any]],
+    api_key: str,
+) -> str:
+    """
+    Core LangGraph lesson planner agent - pure LangGraph implementation.
+
+    This function contains the pure LangGraph logic for creating lesson plans
+    using a state graph architecture with multiple specialized nodes.
+
+    Args:
+        messages: Complete message history from orchestrator
+        api_key: OpenAI API key for the agents
+
+    Returns:
+        The formatted lesson plan as a string
+
+    Raises:
+        Exception: Any errors during agent execution
+    """
+    if not messages:
+        raise ValueError("No messages provided for lesson planning.")
+
+    # Extract the user's topic/request from messages
+    user_prompt = ""
+    for msg in messages:
+        if isinstance(msg, dict) and msg.get("role") == "user":
+            user_prompt = msg.get("content", "")
+            break
+
+    if not user_prompt:
+        # Fallback: use the entire messages as string
+        user_prompt = str(messages)
+    # Initialize the language model
+    llm = ChatOpenAI(
+        model="gpt-4o",
+        api_key=api_key,
+        temperature=0.7,
+    )
+
+    # Define the curriculum standards node
+    async def curriculum_node(state: LessonPlannerState) -> LessonPlannerState:
+        """Determine curriculum standards and learning objectives."""
+        system_msg = SystemMessage(
+            content="""You are a curriculum standards expert for fourth grade education.
+        When given a topic, you provide relevant grade-level standards and learning objectives.
+        Format every response as:
+        STANDARDS:
+        - [Standard 1]
+        - [Standard 2]
+        OBJECTIVES:
+        - By the end of this lesson, students will be able to [objective 1]
+        - By the end of this lesson, students will be able to [objective 2]""",
+        )
+
+        # Build context message if provided
+        context_info = f"\n\nAdditional Context: {state['context']}" if state.get("context") else ""
+        human_msg = HumanMessage(content=f"Please provide fourth grade standards and objectives for: {state['user_prompt']}{context_info}")
+
+        messages_to_send = [system_msg, human_msg]
+        response = await llm.ainvoke(messages_to_send)
+
+        return {
+            "messages": [response],
+            "standards": response.content,
+            "user_prompt": state["user_prompt"],
+            "context": state["context"],
+            "lesson_plan": "",
+            "reviewed_plan": "",
+            "final_plan": "",
+        }
+
+    # Define the lesson planner node
+    async def lesson_planner_node(state: LessonPlannerState) -> LessonPlannerState:
+        """Create a detailed lesson plan based on standards."""
+        system_msg = SystemMessage(
+            content="""You are a lesson planning specialist.
+        Given standards and objectives, you create detailed lesson plans including:
+        - Opening/Hook (5-10 minutes)
+        - Main Activity (20-30 minutes)
+        - Practice Activity (15-20 minutes)
+        - Assessment/Closure (5-10 minutes)
+        Format as a structured lesson plan with clear timing and materials needed.""",
+        )
+
+        human_msg = HumanMessage(content=f"Based on these standards and objectives, create a detailed lesson plan:\n\n{state['standards']}")
+
+        messages_to_send = [system_msg, human_msg]
+        response = await llm.ainvoke(messages_to_send)
+
+        return {
+            "messages": state["messages"] + [response],
+            "lesson_plan": response.content,
+            "user_prompt": state["user_prompt"],
+            "context": state["context"],
+            "standards": state["standards"],
+            "reviewed_plan": "",
+            "final_plan": "",
+        }
+
+    # Define the lesson reviewer node
+    async def lesson_reviewer_node(state: LessonPlannerState) -> LessonPlannerState:
+        """Review and provide feedback on the lesson plan."""
+        system_msg = SystemMessage(
+            content="""You are a lesson plan reviewer who ensures:
+        1. Age-appropriate content and activities
+        2. Alignment with provided standards
+        3. Realistic timing
+        4. Clear instructions
+        5. Differentiation opportunities
+        Provide specific feedback in these areas and suggest improvements if needed.
+        Then provide an improved version of the lesson plan incorporating your feedback.""",
+        )
+
+        human_msg = HumanMessage(content=f"Please review this lesson plan:\n\n{state['lesson_plan']}")
+
+        messages_to_send = [system_msg, human_msg]
+        response = await llm.ainvoke(messages_to_send)
+
+        return {
+            "messages": state["messages"] + [response],
+            "reviewed_plan": response.content,
+            "user_prompt": state["user_prompt"],
+            "context": state["context"],
+            "standards": state["standards"],
+            "lesson_plan": state["lesson_plan"],
+            "final_plan": "",
+        }
+
+    # Define the formatter node
+    async def formatter_node(state: LessonPlannerState) -> LessonPlannerState:
+        """Format the final lesson plan to a standard format."""
+        system_msg = SystemMessage(
+            content="""You are a lesson plan formatter. Format the complete plan as follows:
+<title>Lesson plan title</title>
+<standards>Standards covered</standards>
+<learning_objectives>Key learning objectives</learning_objectives>
+<materials>Materials required</materials>
+<activities>Lesson plan activities</activities>
+<assessment>Assessment details</assessment>""",
+        )
+
+        human_msg = HumanMessage(content=f"Format this reviewed lesson plan:\n\n{state['reviewed_plan']}")
+
+        messages_to_send = [system_msg, human_msg]
+        response = await llm.ainvoke(messages_to_send)
+
+        return {
+            "messages": state["messages"] + [response],
+            "final_plan": response.content,
+            "user_prompt": state["user_prompt"],
+            "context": state["context"],
+            "standards": state["standards"],
+            "lesson_plan": state["lesson_plan"],
+            "reviewed_plan": state["reviewed_plan"],
+        }
+
+    # Build the state graph
+    workflow = StateGraph(LessonPlannerState)
+
+    # Add nodes
+    workflow.add_node("curriculum", curriculum_node)
+    workflow.add_node("planner", lesson_planner_node)
+    workflow.add_node("reviewer", lesson_reviewer_node)
+    workflow.add_node("formatter", formatter_node)
+
+    # Define the flow
+    workflow.set_entry_point("curriculum")
+    workflow.add_edge("curriculum", "planner")
+    workflow.add_edge("planner", "reviewer")
+    workflow.add_edge("reviewer", "formatter")
+    workflow.add_edge("formatter", END)
+
+    # Compile the graph
+    app = workflow.compile()
+
+    # Execute the workflow
+    initial_state = {
+        "messages": [],
+        "user_prompt": user_prompt,
+        "context": "",
+        "standards": "",
+        "lesson_plan": "",
+        "reviewed_plan": "",
+        "final_plan": "",
+    }
+
+    # Extract the final lesson plan
+    final_state = None
+    async for chunk in app.astream(initial_state):
+        for node_name, state_update in chunk.items():
+            if node_name == "formatter" and state_update.get("final_plan"):
+                final_state = state_update
+
+    lesson_plan = final_state.get("final_plan", "No lesson plan generated") if final_state else "No lesson plan generated"
+
+    return lesson_plan
+
+
+@context_params("prompt")
+async def langgraph_lesson_planner(
+    prompt: List[Dict[str, Any]],
+) -> AsyncGenerator[ExecutionResult, None]:
+    """
+    MassGen custom tool wrapper for LangGraph lesson planner.
+
+    This is the interface exposed to MassGen's backend. It handles environment setup,
+    error handling, and wraps the core agent logic in ExecutionResult.
+
+    Args:
+        prompt: processed message list from orchestrator (auto-injected via execution_context)
+
+    Returns:
+        ExecutionResult containing the formatted lesson plan or error message
+    """
+    # Get API key from environment
+    api_key = os.getenv("OPENAI_API_KEY")
+
+    if not api_key:
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data="Error: OPENAI_API_KEY not found. Please set the environment variable."),
+            ],
+        )
+        return
+
+    try:
+        # Call the core agent function with processed messages
+        lesson_plan = await run_langgraph_lesson_planner_agent(
+            messages=prompt,
+            api_key=api_key,
+        )
+
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"LangGraph Lesson Planner Result:\n\n{lesson_plan}"),
+            ],
+        )
+
+    except Exception as e:
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"Error creating lesson plan: {str(e)}"),
+            ],
+        )

massgen/tool/_extraframework_agents/openai_assistant_lesson_planner_tool.py

@@ -0,0 +1,247 @@
+# -*- coding: utf-8 -*-
+"""
+OpenAI Assistant Lesson Planner Tool (Multi-Agent Streaming Version)
+This tool demonstrates interoperability by wrapping OpenAI's Chat Completions API with streaming support
+and multi-agent collaboration pattern similar to AG2.
+"""
+
+import os
+from typing import Any, AsyncGenerator, Dict, List
+
+from openai import AsyncOpenAI
+
+from massgen.tool import context_params
+from massgen.tool._result import ExecutionResult, TextContent
+
+# Define role-specific system prompts (similar to AG2 agents)
+CURRICULUM_AGENT_PROMPT = """You are a curriculum standards expert for fourth grade education.
+When given a topic, you provide relevant grade-level standards and learning objectives.
+Format every response as:
+STANDARDS:
+- [Standard 1]
+- [Standard 2]
+OBJECTIVES:
+- By the end of this lesson, students will be able to [objective 1]
+- By the end of this lesson, students will be able to [objective 2]"""
+
+LESSON_PLANNER_AGENT_PROMPT = """You are a lesson planning specialist.
+Given standards and objectives, you create detailed lesson plans including:
+- Opening/Hook (5-10 minutes)
+- Main Activity (20-30 minutes)
+- Practice Activity (15-20 minutes)
+- Assessment/Closure (5-10 minutes)
+Format as a structured lesson plan with clear timing and materials needed."""
+
+LESSON_REVIEWER_AGENT_PROMPT = """You are a lesson plan reviewer who ensures:
+1. Age-appropriate content and activities
+2. Alignment with provided standards
+3. Realistic timing
+4. Clear instructions
+5. Differentiation opportunities
+Provide specific feedback in these areas and suggest improvements if needed."""
+
+LESSON_FORMATTER_AGENT_PROMPT = """You are a lesson plan formatter. Format the complete plan as follows:
+<title>Lesson plan title</title>
+<standards>Standards covered</standards>
+<learning_objectives>Key learning objectives</learning_objectives>
+<materials>Materials required</materials>
+<activities>Detailed lesson plan activities with timing</activities>
+<assessment>Assessment details</assessment>"""
+
+
+async def run_agent_step(
+    client: AsyncOpenAI,
+    role_prompt: str,
+    user_message: str,
+    temperature: float = 0.7,
+) -> str:
+    """
+    Run a single agent step with streaming and collect the full response.
+
+    Args:
+        client: AsyncOpenAI client
+        role_prompt: System prompt for this agent role
+        user_message: User message to process
+        temperature: Temperature for generation
+
+    Returns:
+        Complete response from the agent
+    """
+    messages = [
+        {"role": "system", "content": role_prompt},
+        {"role": "user", "content": user_message},
+    ]
+
+    stream = await client.chat.completions.create(
+        model="gpt-4o",
+        messages=messages,
+        stream=True,
+        temperature=temperature,
+    )
+
+    full_response = ""
+    async for chunk in stream:
+        if chunk.choices and len(chunk.choices) > 0:
+            delta = chunk.choices[0].delta
+            if delta.content:
+                full_response += delta.content
+
+    return full_response
+
+
+@context_params("prompt")
+async def openai_assistant_lesson_planner(
+    prompt: List[Dict[str, Any]],
+) -> AsyncGenerator[ExecutionResult, None]:
+    """
+    MassGen custom tool wrapper for OpenAI lesson planner with multi-agent collaboration.
+
+    This version uses multiple specialized agents (similar to AG2) to collaboratively create
+    a lesson plan through sequential steps:
+    1. Curriculum Agent: Identifies standards and objectives
+    2. Lesson Planner Agent: Creates the detailed lesson plan
+    3. Lesson Reviewer Agent: Reviews and provides feedback
+    4. Formatter Agent: Formats the final plan
+
+    Args:
+        prompt: processed message list from orchestrator (auto-injected via execution_context)
+
+    Yields:
+        ExecutionResult containing text chunks as they arrive, or error messages
+    """
+    # Get API key from environment
+    api_key = os.getenv("OPENAI_API_KEY")
+
+    if not api_key:
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data="Error: OPENAI_API_KEY not found. Please set the environment variable."),
+            ],
+        )
+        return
+
+    if not prompt:
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data="Error: No messages provided for lesson planning."),
+            ],
+        )
+        return
+
+    try:
+        # Initialize OpenAI client
+        client = AsyncOpenAI(api_key=api_key)
+
+        # Extract the user's request
+        user_request = str(prompt)
+
+        # Yield an initial message
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data="OpenAI Lesson Planner (Multi-Agent Collaboration):\n\n"),
+            ],
+        )
+
+        # Step 1: Curriculum Agent - Determine standards and objectives
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data="[Curriculum Agent] Identifying standards and objectives...\n"),
+            ],
+            is_log=True,
+        )
+
+        standards_and_objectives = await run_agent_step(
+            client,
+            CURRICULUM_AGENT_PROMPT,
+            f"Please provide fourth grade standards and objectives for: {user_request}",
+        )
+
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"{standards_and_objectives}\n\n"),
+            ],
+            is_log=True,
+        )
+
+        # Step 2: Lesson Planner Agent - Create detailed lesson plan
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data="[Lesson Planner Agent] Creating detailed lesson plan...\n"),
+            ],
+            is_log=True,
+        )
+
+        lesson_plan = await run_agent_step(
+            client,
+            LESSON_PLANNER_AGENT_PROMPT,
+            f"Based on these standards and objectives:\n{standards_and_objectives}\n\nCreate a detailed lesson plan for: {user_request}",
+        )
+
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"{lesson_plan}\n\n"),
+            ],
+            is_log=True,
+        )
+
+        # Step 3: Lesson Reviewer Agent - Review and provide feedback
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data="[Lesson Reviewer Agent] Reviewing lesson plan...\n"),
+            ],
+            is_log=True,
+        )
+
+        review_feedback = await run_agent_step(
+            client,
+            LESSON_REVIEWER_AGENT_PROMPT,
+            f"Review this lesson plan:\n{lesson_plan}\n\nProvide feedback and suggest improvements.",
+        )
+
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"{review_feedback}\n\n"),
+            ],
+            is_log=True,
+        )
+
+        # Step 4: Formatter Agent - Format the final plan with streaming
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data="[Formatter Agent] Formatting final lesson plan...\n\n"),
+            ],
+            is_log=True,
+        )
+
+        messages = [
+            {"role": "system", "content": LESSON_FORMATTER_AGENT_PROMPT},
+            {
+                "role": "user",
+                "content": f"Format this complete lesson plan:\n\nStandards and Objectives:\n{standards_and_objectives}\n\nLesson Plan:\n{lesson_plan}\n\nReview Feedback:\n{review_feedback}",
+            },
+        ]
+
+        stream = await client.chat.completions.create(
+            model="gpt-4o",
+            messages=messages,
+            stream=True,
+            temperature=0.7,
+        )
+
+        # Stream the final formatted output
+        async for chunk in stream:
+            if chunk.choices and len(chunk.choices) > 0:
+                delta = chunk.choices[0].delta
+                if delta.content:
+                    yield ExecutionResult(
+                        output_blocks=[
+                            TextContent(data=delta.content),
+                        ],
+                    )
+
+    except Exception as e:
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"\nError during lesson planning: {str(e)}"),
+            ],
+        )

massgen/tool/_extraframework_agents/smolagent_lesson_planner_tool.py

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+"""
+SmolAgent Lesson Planner Tool
+This tool demonstrates interoperability by wrapping HuggingFace's SmolAgent framework as a MassGen custom tool.
+"""
+
+import os
+from typing import Any, AsyncGenerator, Dict, List
+
+from smolagents import CodeAgent, LiteLLMModel, tool
+
+from massgen.tool import context_params
+from massgen.tool._result import ExecutionResult, TextContent
+
+
+def run_smolagent_lesson_planner_agent(
+    messages: List[Dict[str, Any]],
+    api_key: str,
+) -> str:
+    """
+    Core SmolAgent lesson planner agent - pure SmolAgent implementation.
+
+    This function contains the pure SmolAgent logic for creating lesson plans
+    using custom tools and CodeAgent.
+
+    Args:
+        messages: Complete message history from orchestrator
+        api_key: OpenAI API key for the agents
+
+    Returns:
+        The formatted lesson plan as a string
+
+    Raises:
+        Exception: Any errors during agent execution
+    """
+    if not messages:
+        raise ValueError("No messages provided for lesson planning.")
+
+    # Define custom tools for the lesson planning workflow
+    @tool
+    def get_curriculum_standards(topic: str) -> str:
+        """
+        Determine fourth grade curriculum standards and learning objectives for a given topic.
+
+        Args:
+            topic: The lesson topic to get standards for
+
+        Returns:
+            A formatted string with standards and objectives
+        """
+        # This tool would interact with the LLM to generate standards
+        return f"Generate fourth grade curriculum standards and learning objectives for: {topic}"
+
+    @tool
+    def create_lesson_plan(topic: str, standards: str) -> str:
+        """
+        Create a detailed lesson plan based on topic and standards.
+
+        Args:
+            topic: The lesson topic
+            standards: The curriculum standards and objectives
+
+        Returns:
+            A detailed lesson plan with activities and timing
+        """
+        return f"Create a detailed lesson plan for '{topic}' based on these standards: {standards}"
+
+    @tool
+    def review_lesson_plan(lesson_plan: str) -> str:
+        """
+        Review a lesson plan for age-appropriateness, timing, and engagement.
+
+        Args:
+            lesson_plan: The lesson plan to review
+
+        Returns:
+            An improved version of the lesson plan
+        """
+        return f"Review and improve this lesson plan: {lesson_plan}"
+
+    @tool
+    def format_lesson_plan(lesson_plan: str) -> str:
+        """
+        Format a lesson plan to a standardized structure.
+
+        Args:
+            lesson_plan: The lesson plan to format
+
+        Returns:
+            A formatted lesson plan with XML-like tags
+        """
+        return (
+            f"Format this lesson plan with the following structure:\n"
+            f"<title>Lesson plan title</title>\n"
+            f"<standards>Standards covered</standards>\n"
+            f"<learning_objectives>Key learning objectives</learning_objectives>\n"
+            f"<materials>Materials required</materials>\n"
+            f"<activities>Detailed lesson plan activities with timing</activities>\n"
+            f"<assessment>Assessment details</assessment>\n\n"
+            f"Lesson plan to format: {lesson_plan}"
+        )
+
+    # Initialize the model
+    model = LiteLLMModel(
+        model_id="openai/gpt-4o",
+        api_key=api_key,
+    )
+
+    # Create the agent with custom tools
+    agent = CodeAgent(
+        tools=[get_curriculum_standards, create_lesson_plan, review_lesson_plan, format_lesson_plan],
+        model=model,
+        max_steps=10,
+    )
+
+    # Build the task from messages
+    task = f"Create a comprehensive fourth grade lesson plan for: {messages}\n\n"
+    task += "Please follow these steps:\n"
+    task += "1. Use get_curriculum_standards to identify relevant standards\n"
+    task += "2. Use create_lesson_plan to create a detailed plan\n"
+    task += "3. Use review_lesson_plan to review and improve the plan\n"
+    task += "4. Use format_lesson_plan to format the final output\n\n"
+    task += "The final plan should include:\n"
+    task += "- Opening/Hook (5-10 minutes)\n"
+    task += "- Main Activity (20-30 minutes)\n"
+    task += "- Practice Activity (15-20 minutes)\n"
+    task += "- Assessment/Closure (5-10 minutes)"
+
+    # Run the agent
+    result = agent.run(task)
+
+    return result
+
+
+@context_params("prompt")
+async def smolagent_lesson_planner(
+    prompt: List[Dict[str, Any]],
+) -> AsyncGenerator[ExecutionResult, None]:
+    """
+    MassGen custom tool wrapper for SmolAgent lesson planner.
+
+    This is the interface exposed to MassGen's backend. It handles environment setup,
+    error handling, and wraps the core agent logic in ExecutionResult.
+
+    Args:
+        prompt: processed message list from orchestrator (auto-injected via execution_context)
+
+    Returns:
+        ExecutionResult containing the formatted lesson plan or error message
+    """
+    # Get API key from environment
+    api_key = os.getenv("OPENAI_API_KEY")
+
+    if not api_key:
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data="Error: OPENAI_API_KEY not found. Please set the environment variable."),
+            ],
+        )
+        return
+
+    try:
+        # Call the core agent function with processed messages
+        lesson_plan = run_smolagent_lesson_planner_agent(
+            messages=prompt,
+            api_key=api_key,
+        )
+
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"SmolAgent Lesson Planner Result:\n\n{lesson_plan}"),
+            ],
+        )
+
+    except Exception as e:
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"Error creating lesson plan: {str(e)}"),
+            ],
+        )