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

massgen/tool/_extraframework_agents/agentscope_lesson_planner_tool.py

@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+"""
+AgentScope Lesson Planner Tool
+This tool demonstrates interoperability by wrapping AgentScope's multi-agent framework as a MassGen custom tool.
+Compatible with AgentScope 1.0.6+
+"""
+
+import os
+from typing import Any, AsyncGenerator, Dict, List
+
+import agentscope
+from agentscope.agent import AgentBase
+from agentscope.formatter import OpenAIChatFormatter
+from agentscope.memory import InMemoryMemory
+from agentscope.message import Msg
+from agentscope.model import OpenAIChatModel
+
+from massgen.tool import context_params
+from massgen.tool._result import ExecutionResult, TextContent
+
+
+class SimpleDialogAgent(AgentBase):
+    """
+    A simple dialog agent for AgentScope 1.0.6+
+    This is a lightweight replacement for the deprecated DialogAgent.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        sys_prompt: str,
+        model: OpenAIChatModel,
+    ):
+        """
+        Initialize the dialog agent.
+
+        Args:
+            name: Agent name
+            sys_prompt: System prompt for the agent
+            model: OpenAI chat model instance
+        """
+        super().__init__()
+        self.name = name
+        self.sys_prompt = sys_prompt
+        self.model = model
+        self.formatter = OpenAIChatFormatter()
+        self.memory = InMemoryMemory()
+
+        # Store system prompt to add later (memory operations are async)
+        self.pending_sys_msg = None
+        if sys_prompt:
+            self.pending_sys_msg = Msg(name="system", content=sys_prompt, role="system")
+
+    async def reply(self, x: Msg = None) -> Msg:
+        """
+        Generate a reply to the input message.
+
+        Args:
+            x: Input message
+
+        Returns:
+            Response message
+        """
+        # Add system prompt on first call
+        if self.pending_sys_msg is not None:
+            await self.memory.add(self.pending_sys_msg)
+            self.pending_sys_msg = None
+
+        # Add user message to memory
+        if x is not None:
+            await self.memory.add(x)
+
+        # Get conversation history
+        history = await self.memory.get_memory()
+
+        # Format messages for the model
+        formatted_msgs = []
+        for msg in history:
+            formatted_msgs.append(
+                {
+                    "role": msg.role,
+                    "content": msg.content if isinstance(msg.content, str) else str(msg.content),
+                },
+            )
+
+        # Generate response using the model
+        response = await self.model(formatted_msgs)
+
+        # Extract content from ChatResponse
+        # response.content is a list like [{'type': 'text', 'text': '...'}]
+        content = ""
+        if hasattr(response, "content") and isinstance(response.content, list):
+            for item in response.content:
+                if isinstance(item, dict) and item.get("type") == "text":
+                    content += item.get("text", "")
+        elif hasattr(response, "content"):
+            content = str(response.content)
+        else:
+            content = str(response)
+
+        # Create response message
+        response_msg = Msg(
+            name=self.name,
+            content=content,
+            role="assistant",
+        )
+
+        # Add response to memory
+        await self.memory.add(response_msg)
+
+        return response_msg
+
+
+async def run_agentscope_lesson_planner_agent(
+    messages: List[Dict[str, Any]],
+    api_key: str,
+) -> str:
+    """
+    Core AgentScope lesson planner agent - pure AgentScope implementation.
+
+    This function contains the pure AgentScope logic for creating lesson plans
+    using multiple specialized DialogAgents in a sequential pipeline.
+
+    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
+    # Messages is typically a list of dicts with 'role' and 'content'
+    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 AgentScope (simplified for 1.0.6)
+    agentscope.init(
+        project="massgen_lesson_planner",
+        name="agentscope_lesson_planner_run",
+        logging_level="WARNING",
+    )
+
+    # Create shared model instance
+    model = OpenAIChatModel(
+        model_name="gpt-4o",
+        api_key=api_key,
+        stream=False,
+        generate_kwargs={
+            "temperature": 0.7,
+        },
+    )
+
+    # Create specialized agents for each step
+    curriculum_agent = SimpleDialogAgent(
+        name="Curriculum_Standards_Expert",
+        sys_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]""",
+        model=model,
+    )
+
+    lesson_planner_agent = SimpleDialogAgent(
+        name="Lesson_Planning_Specialist",
+        sys_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.""",
+        model=model,
+    )
+
+    reviewer_agent = SimpleDialogAgent(
+        name="Lesson_Plan_Reviewer",
+        sys_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 an improved version of the lesson plan incorporating your feedback.""",
+        model=model,
+    )
+
+    formatter_agent = SimpleDialogAgent(
+        name="Lesson_Plan_Formatter",
+        sys_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>""",
+        model=model,
+    )
+
+    # Build the initial message
+    initial_message = f"Please provide fourth grade standards and objectives for: {user_prompt}"
+
+    # Create the sequential pipeline
+    # Step 1: Get curriculum standards
+    msg = Msg(name="User", content=initial_message, role="user")
+    standards_response = await curriculum_agent.reply(msg)
+
+    # Step 2: Create lesson plan based on standards
+    lesson_msg = Msg(
+        name="User",
+        content=f"Based on these standards and objectives, create a detailed lesson plan:\n\n{standards_response.content}",
+        role="user",
+    )
+    lesson_response = await lesson_planner_agent.reply(lesson_msg)
+
+    # Step 3: Review and improve the lesson plan
+    review_msg = Msg(
+        name="User",
+        content=f"Please review and improve this lesson plan:\n\n{lesson_response.content}",
+        role="user",
+    )
+    reviewed_response = await reviewer_agent.reply(review_msg)
+
+    # Step 4: Format the final lesson plan
+    format_msg = Msg(
+        name="User",
+        content=f"Format this reviewed lesson plan:\n\n{reviewed_response.content}",
+        role="user",
+    )
+    final_response = await formatter_agent.reply(format_msg)
+
+    # Extract the final lesson plan
+    lesson_plan = final_response.content if isinstance(final_response.content, str) else str(final_response.content)
+
+    return lesson_plan
+
+
+@context_params("prompt")
+async def agentscope_lesson_planner(
+    prompt: List[Dict[str, Any]],
+) -> AsyncGenerator[ExecutionResult, None]:
+    """
+    MassGen custom tool wrapper for AgentScope 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_agentscope_lesson_planner_agent(
+            messages=prompt,
+            api_key=api_key,
+        )
+
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"AgentScope Lesson Planner Result:\n\n{lesson_plan}"),
+            ],
+        )
+
+    except Exception as e:
+        import traceback
+
+        error_details = traceback.format_exc()
+        yield ExecutionResult(
+            output_blocks=[
+                TextContent(data=f"Error creating lesson plan: {str(e)}\n\nDetails:\n{error_details}"),
+            ],
+        )

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)}"),
+            ],
+        )