Debugging, Testing, and Monitoring: Building Reliable Agent Systems

pip install pytest==8.1.1

# langgraph_debug.py
import os
import logging
from typing import Literal

from langchain_core.messages import BaseMessage, HumanMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END

# --- Setup Logging ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- Environment Variable Check ---
# Make sure to set your OPENAI_API_KEY environment variable.
if not os.getenv("OPENAI_API_KEY"):
    logger.warning("OPENAI_API_KEY environment variable not set. LLM calls might fail or use a mock.")
    # For demonstration, we'll proceed, but in a real app, you'd handle this more robustly.

# --- Define Graph State ---
class AgentState:
    messages: list[BaseMessage]
    topic: Literal["math", "general", "unknown"] = "unknown"

# --- LLM Setup ---
# Using gpt-4o as of 2026-03-20. Ensure OPENAI_API_KEY is set in your environment.
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# --- Agent Nodes ---
def classify_topic(state: AgentState) -> AgentState:
    """Classifies the topic of the conversation."""
    logger.info(f"Node 'classify_topic' entered. Current messages: {state.messages}")
    last_message = state.messages[-1].content
    
    prompt = f"""
    Analyze the following user query and determine if it's primarily about 'math' or 'general' topics.
    Respond with only one word: 'math' or 'general'.

    Query: "{last_message}"
    """
    
    response = llm.invoke(prompt)
    classification = response.content.strip().lower()

    new_state = AgentState(messages=state.messages, topic=state.topic) # Start with current state
    if "math" in classification:
        new_state.topic = "math"
        logger.info("Topic classified as: math")
    elif "general" in classification:
        new_state.topic = "general"
        logger.info("Topic classified as: general")
    else:
        new_state.topic = "unknown"
        logger.warning(f"Could not classify topic. LLM response: '{classification}'. Defaulting to unknown.")
    
    return new_state

def handle_math_query(state: AgentState) -> AgentState:
    """Handles math-related queries."""
    logger.info(f"Node 'handle_math_query' entered. Current messages: {state.messages}")
    last_message = state.messages[-1].content
    
    response_content = f"I'm a math expert! Let me help with: '{last_message}'"
    new_message = HumanMessage(content=response_content)
    
    new_state = AgentState(messages=state.messages + [new_message], topic=state.topic)
    logger.info(f"Math query handled. Response: {response_content}")
    return new_state

def handle_general_query(state: AgentState) -> AgentState:
    """Handles general queries."""
    logger.info(f"Node 'handle_general_query' entered. Current messages: {state.messages}")
    last_message = state.messages[-1].content
    
    response_content = f"I'm a general knowledge expert! Here's my take on: '{last_message}'"
    new_message = HumanMessage(content=response_content)
    
    new_state = AgentState(messages=state.messages + [new_message], topic=state.topic)
    logger.info(f"General query handled. Response: {response_content}")
    return new_state

# --- Conditional Edges ---
def route_topic(state: AgentState) -> Literal["math_handler", "general_handler"]:
    """Routes based on the classified topic."""
    logger.info(f"Node 'route_topic' entered. Current topic: {state.topic}")
    if state.topic == "math":
        logger.info("Routing to math_handler.")
        return "math_handler"
    else: # Fallback to general handler for 'general' or 'unknown'
        logger.info(f"Routing to general_handler (topic was '{state.topic}').")
        return "general_handler"

# --- Build the Graph ---
workflow = StateGraph(AgentState)

# Add nodes
workflow.add_node("classify", classify_topic)
workflow.add_node("math_handler", handle_math_query)
workflow.add_node("general_handler", handle_general_query)

# Set entry point
workflow.set_entry_point("classify")

# Add edges
workflow.add_conditional_edges(
    "classify",
    route_topic,
    {
        "math_handler": "math_handler",
        "general_handler": "general_handler", # Handles both 'general' and 'unknown' topics
    },
)

# Set end points
workflow.add_edge("math_handler", END)
workflow.add_edge("general_handler", END)

# Compile the graph
app = workflow.compile()

# --- Run the Agent ---
if __name__ == "__main__":
    print("--- Running LangGraph Agent ---")

    # Example 1: Math query
    print("\nQuery: 'What is the square root of 9?'")
    initial_state_math = AgentState(messages=[HumanMessage(content="What is the square root of 9?")])
    result_math = app.invoke(initial_state_math)
    print(f"Final Math Response: {result_math.messages[-1].content}")

    # Example 2: General query
    print("\nQuery: 'Tell me a fun fact about cats.'")
    initial_state_general = AgentState(messages=[HumanMessage(content="Tell me a fun fact about cats.")])
    result_general = app.invoke(initial_state_general)
    print(f"Final General Response: {result_general.messages[-1].content}")

    # Example 3: Ambiguous query (should fallback to general)
    print("\nQuery: 'Purple elephant flying in space.'")
    initial_state_ambiguous = AgentState(messages=[HumanMessage(content="Purple elephant flying in space.")])
    result_ambiguous = app.invoke(initial_state_ambiguous)
    print(f"Final Ambiguous Response: {result_ambiguous.messages[-1].content}")

# test_langgraph_nodes.py
import pytest
import os
from unittest.mock import MagicMock

from langchain_core.messages import HumanMessage
from langgraph_debug import classify_topic, AgentState # Import from our previous file

# Mock the LLM to make tests deterministic and avoid API calls
@pytest.fixture
def mock_llm_response():
    """Fixture to mock the LLM's invoke method."""
    # Store the original LLM invoke method
    original_llm_invoke = classify_topic.__globals__['llm'].invoke
    
    def mock_invoke_logic(prompt):
        """Custom logic for the mocked LLM invoke."""
        if "square root" in prompt.lower() or "math" in prompt.lower():
            mock_response = MagicMock()
            mock_response.content = "math"
            return mock_response
        elif "fun fact" in prompt.lower() or "general" in prompt.lower():
            mock_response = MagicMock()
            mock_response.content = "general"
            return mock_response
        else:
            mock_response = MagicMock()
            mock_response.content = "unknown_classification"
            return mock_response
            
    # Replace the actual LLM's invoke with our mock logic
    classify_topic.__globals__['llm'].invoke = mock_invoke_logic
    yield # Run the test
    # Restore the original LLM invoke method after the test
    classify_topic.__globals__['llm'].invoke = original_llm_invoke

def test_classify_topic_math(mock_llm_response):
    """Test if classify_topic correctly identifies a math query."""
    initial_state = AgentState(messages=[HumanMessage(content="What is the square root of 16?")])
    result_state = classify_topic(initial_state)
    assert result_state.topic == "math"

def test_classify_topic_general(mock_llm_response):
    """Test if classify_topic correctly identifies a general query."""
    initial_state = AgentState(messages=[HumanMessage(content="Tell me a fun fact about giraffes.")])
    result_state = classify_topic(initial_state)
    assert result_state.topic == "general"

def test_classify_topic_unknown(mock_llm_response):
    """Test if classify_topic handles an unknown query."""
    initial_state = AgentState(messages=[HumanMessage(content="Purple elephants fly on Tuesdays.")])
    result_state = classify_topic(initial_state)
    assert result_state.topic == "unknown"

pip install pyautogen==0.2.20

# autogen_debug.py
import os
import autogen
import logging

# --- Setup Logging ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- Environment Variable Check and AutoGen Configuration ---
# It's best practice to load API keys from environment variables for security.
# Make sure to set your OPENAI_API_KEY environment variable.
openai_api_key = os.getenv("OPENAI_API_KEY")
if not openai_api_key:
    logger.error("OPENAI_API_KEY environment variable not set. AutoGen will likely fail without it.")
    # In a real application, you might exit or provide a mock here.
    exit("Please set the OPENAI_API_KEY environment variable.")

# AutoGen config list using the environment variable
config_list = [
    {
        "model": "gpt-4o", # Using gpt-4o as of 2026-03-20
        "api_key": openai_api_key,
    }
]

# --- Define Agents ---
# The User Proxy Agent is typically the entry point for human interaction or initiating tasks.
user_proxy = autogen.UserProxyAgent(
    name="Admin",
    system_message="A human admin. Interact with the Planner to ensure tasks are completed.",
    code_execution_config={"last_n_messages": 3, "work_dir": "coding"},
    human_input_mode="NEVER", # Set to ALWAYS for interactive debugging
    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
)

# The Planner Agent will receive the initial task and break it down.
planner = autogen.AssistantAgent(
    name="Planner",
    llm_config={"config_list": config_list}, # Use the config_list with API key
    system_message="""You are a helpful AI assistant that plans tasks.
    Your goal is to break down a complex request into smaller, manageable steps for other agents.
    When you have a plan, present it clearly.
    If the task involves code, just state "I will write code to solve this."
    Once the task is fully planned or completed, respond with TERMINATE.
    """,
)

# --- Define a GroupChat ---
groupchat = autogen.GroupChat(agents=[user_proxy, planner], messages=[], max_round=5)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config={"config_list": config_list})

# --- Run the Conversation ---
if __name__ == "__main__":
    print("--- Running AutoGen Agent Conversation ---")
    
    # Start a conversation
    print("\nStarting conversation: 'Plan a simple Python script to calculate the factorial of a number.'")
    user_proxy.initiate_chat(
        manager,
        message="Plan a simple Python script to calculate the factorial of a number.",
    )

    print("\n--- Conversation History (for Debugging) ---")
    # Accessing the conversation history is a key debugging technique in AutoGen
    # This shows the full back-and-forth between agents
    for msg in user_proxy.chat_messages[manager]:
        print(f"[{msg['name']}]: {msg['content']}")

# test_autogen_agents.py
import pytest
import os
import autogen
from unittest.mock import patch, MagicMock

# --- AutoGen Configuration (for testing) ---
# We'll use a mock config list to avoid actual API calls during tests
test_config_list = [
    {
        "model": "mock-model", # Use a placeholder model name
        "api_key": "mock-key", # Use a placeholder API key (won't be used due to mocking)
    }
]

# --- Mock LLM for AutoGen ---
@pytest.fixture
def mock_autogen_llm():
    """Fixture to mock the LLM calls within AutoGen agents."""
    # Patch the underlying Completion.create method that AutoGen uses for LLM calls.
    with patch('autogen.Completion.create') as mock_create:
        def side_effect(*args, **kwargs):
            messages = kwargs.get('messages', [])
            last_message_content = messages[-1]['content'].lower() if messages else ""

            if "plan a simple python script" in last_message_content:
                response_content = "Plan: 1. Define a function for factorial. 2. Use a loop. 3. Return result. TERMINATE"
            elif "factorial of a number" in last_message_content: # For the planner's response
                response_content = "To calculate the factorial, you need a loop. TERMINATE"
            else:
                response_content = "Mock response for unknown query. TERMINATE"
            
            mock_choice = MagicMock()
            mock_choice.message.content = response_content
            mock_choice.message.function_call = None
            mock_choice.finish_reason = "stop"
            
            mock_response = MagicMock()
            mock_response.choices = [mock_choice]
            mock_response.usage.prompt_tokens = 10
            mock_response.usage.completion_tokens = 10
            return mock_response
        
        mock_create.side_effect = side_effect
        yield mock_create

def test_autogen_factorial_planning(mock_autogen_llm):
    """Test if AutoGen agents can plan a factorial script."""
    
    # Redefine agents for the test to ensure they use the mock config list
    user_proxy = autogen.UserProxyAgent(
        name="Admin",
        system_message="A human admin. Interact with the Planner to ensure tasks are completed.",
        code_execution_config={"last_n_messages": 3, "work_dir": "coding"},
        human_input_mode="NEVER",
        is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
    )

    planner = autogen.AssistantAgent(
        name="Planner",
        llm_config={"config_list": test_config_list}, # Use the mock config list
        system_message="""You are a helpful AI assistant that plans tasks.
        Your goal is to break down a complex request into smaller, manageable steps for other agents.
        When you have a plan, present it clearly.
        If the task involves code, just state "I will write code to solve this."
        Once the task is fully planned or completed, respond with TERMINATE.
        """,
    )

    groupchat = autogen.GroupChat(agents=[user_proxy, planner], messages=[], max_round=5)
    manager = autogen.GroupChatManager(groupchat=groupchat, llm_config={"config_list": test_config_list})

    # Initiate the chat
    user_proxy.initiate_chat(
        manager,
        message="Plan a simple Python script to calculate the factorial of a number.",
    )

    # Assertions: Check the last message from the Planner
    # We expect the Planner to have provided a plan and terminated.
    last_message = user_proxy.chat_messages[manager][-1]['content']
    assert "TERMINATE" in last_message
    assert "Plan:" in last_message
    assert "factorial" in last_message.lower()

pip install crewai==0.28.8 langchain-openai==0.1.1 # As of 2026-03-20

# crewai_debug.py
import os
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI
import logging

# --- Setup Logging ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- Environment Variable Check ---
if not os.getenv("OPENAI_API_KEY"):
    logger.error("OPENAI_API_KEY environment variable not set. CrewAI will likely fail without it.")
    exit("Please set the OPENAI_API_KEY environment variable.")

# --- LLM Setup ---
# Using gpt-4o as of 2026-03-20
# CrewAI can pick up the model from this env var, or you can pass it explicitly.
os.environ["OPENAI_MODEL_NAME"] = "gpt-4o" 

# --- Define Agents ---
researcher = Agent(
    role='Senior Research Analyst',
    goal='Uncover critical insights about the tech industry',
    backstory="""You are a Senior Research Analyst at a leading tech firm.
    Your expertise lies in identifying emerging trends and market shifts.""",
    verbose=True, # CRITICAL for debugging: shows agent's thought process
    allow_delegation=False,
    llm=ChatOpenAI(model="gpt-4o", temperature=0) # Explicitly set LLM for this agent
)

writer = Agent(
    role='Content Strategist',
    goal='Craft compelling narratives from research findings',
    backstory="""You are a Content Strategist, skilled in transforming complex data
    into engaging and easy-to-understand reports.""",
    verbose=True, # CRITICAL for debugging
    allow_delegation=False,
    llm=ChatOpenAI(model="gpt-4o", temperature=0)
)

# --- Define Tasks ---
research_task = Task(
    description="Analyze the latest trends in AI and cloud computing.",
    expected_output="A concise summary of 3-5 key trends in AI and cloud computing.",
    agent=researcher
)

write_report_task = Task(
    description="Write a short report (2-3 paragraphs) based on the research findings.",
    expected_output="A well-structured 2-3 paragraph report summarizing AI and cloud trends.",
    agent=writer
)

# --- Form the Crew ---
tech_crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_report_task],
    process=Process.sequential,
    verbose=True, # CRITICAL for debugging: shows overall crew execution
)

# --- Run the Crew ---
if __name__ == "__main__":
    print("--- Running CrewAI Agent System ---")
    
    # Kick off the crew's work
    result = tech_crew.kickoff()
    print("\n--- CrewAI Execution Result ---")
    print(result)

# test_crewai_tasks.py
import pytest
import os
from unittest.mock import patch, MagicMock
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

# --- Mock LLM for CrewAI ---
@pytest.fixture
def mock_crewai_llm():
    """Fixture to mock the LLM calls within CrewAI agents."""
    # Patch the 'invoke' method of ChatOpenAI instances.
    with patch('langchain_openai.chat_models.ChatOpenAI.invoke') as mock_invoke:
        def side_effect(*args, **kwargs):
            # Simulate LLM response based on prompt content
            message_content = kwargs.get('messages', [])[-1].content if kwargs.get('messages') else ""

            if "latest trends in AI and cloud computing" in message_content:
                response_text = "AI trends: Gen AI, Edge AI. Cloud trends: Serverless, Hybrid Cloud. TERMINATE"
            elif "write a short report" in message_content:
                response_text = "Report: Generative AI and Edge AI are booming. Cloud computing is evolving with serverless architectures and hybrid cloud solutions. These trends are shaping the future. TERMINATE"
            else:
                response_text = "Mocked LLM response. TERMINATE"
            
            mock_response = MagicMock()
            mock_response.content = response_text
            mock_response.tool_calls = [] # No tool calls in this simple mock
            return mock_response
        
        mock_invoke.side_effect = side_effect
        yield mock_invoke

def test_crewai_research_task(mock_crewai_llm):
    """Test the research task in isolation."""
    # Define agent and task specifically for this test
    researcher = Agent(
        role='Test Research Analyst',
        goal='Uncover specific test insights',
        backstory="You are a test researcher.",
        verbose=False, # Turn off verbose for cleaner test output
        allow_delegation=False,
        llm=ChatOpenAI(model="gpt-4o", temperature=0) # LLM will be mocked by the fixture
    )

    research_task = Task(
        description="Analyze the latest trends in AI and cloud computing.",
        expected_output="A concise summary of 3-5 key trends.",
        agent=researcher
    )

    # Execute the task
    result = research_task.execute()

    # Assertions
    assert "AI trends:" in result
    assert "Cloud trends:" in result
    assert "Gen AI" in result
    assert "Serverless" in result

def test_crewai_full_crew_execution(mock_crewai_llm):
    """Test the full crew execution and final report."""
    # Define agents
    researcher = Agent(
        role='Test Research Analyst',
        goal='Uncover specific test insights',
        backstory="You are a test researcher.",
        verbose=False,
        allow_delegation=False,
        llm=ChatOpenAI(model="gpt-4o", temperature=0) # LLM will be mocked
    )

    writer = Agent(
        role='Test Content Strategist',
        goal='Craft test narratives',
        backstory="You are a test writer.",
        verbose=False,
        allow_delegation=False,
        llm=ChatOpenAI(model="gpt-4o", temperature=0) # LLM will be mocked
    )

    # Define tasks
    research_task = Task(
        description="Analyze the latest trends in AI and cloud computing.",
        expected_output="A concise summary of 3-5 key trends in AI and cloud computing.",
        agent=researcher
    )

    write_report_task = Task(
        description="Write a short report (2-3 paragraphs) based on the research findings.",
        expected_output="A well-structured 2-3 paragraph report summarizing AI and cloud trends.",
        agent=writer
    )

    # Form the Crew
    tech_crew = Crew(
        agents=[researcher, writer],
        tasks=[research_task, write_report_task],
        process=Process.sequential,
        verbose=False,
    )

    # Kick off the crew's work
    result = tech_crew.kickoff()

    # Assertions for the final report
    assert "Report:" in result
    assert "Generative AI and Edge AI are booming." in result
    assert "Cloud computing is evolving with serverless architectures" in result

pip install semantic-kernel==0.9.1b1 # As of 2026-03-20

# sk_debug.py
import os
import logging
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAICompletion, OpenAIChatCompletion
from semantic_kernel.functions import kernel_function

# --- Setup Logging ---
# Configure SK's internal logging to be verbose
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- Environment Variable Check ---
if not os.getenv("OPENAI_API_KEY"):
    logger.error("OPENAI_API_KEY environment variable not set. Semantic Kernel will likely fail without it.")
    exit("Please set the OPENAI_API_KEY environment variable.")

# --- Define a simple skill for demonstration ---
class MathSkill:
    @kernel_function(
        description="Adds two numbers together.",
        name="Add",
        parameters=[
            {"name": "input", "description": "The first number to add", "type": "string", "required": True},
            {"name": "number2", "description": "The second number to add", "type": "string", "required": True},
        ],
    )
    def add(self, input: str, number2: str) -> str:
        logger.info(f"MathSkill.Add called with input='{input}', number2='{number2}'")
        try:
            result = float(input) + float(number2)
            return str(result)
        except ValueError:
            logger.error(f"Invalid input for MathSkill.Add: '{input}', '{number2}'")
            return "Error: Invalid numbers provided."

# --- Initialize Kernel and LLM ---
async def main():
    kernel = Kernel()

    # Add the OpenAI chat completion service
    # Using gpt-4o as of 2026-03-20
    kernel.add_service(
        OpenAIChatCompletion(
            service_id="default",
            ai_model_id="gpt-4o",
            api_key=os.getenv("OPENAI_API_KEY"),
        ),
    )

    # Import the custom skill
    kernel.import_plugin_from_object(MathSkill(), plugin_name="MyMath")

    # Define a prompt function that uses the skill
    prompt_template = """
    You are a helpful assistant.
    User query: {{ $input }}

    If the query involves adding two numbers, use the MyMath.Add skill.
    Otherwise, answer generally.
    """
    math_assistant_function = kernel.create_function_from_prompt(
        prompt_template=prompt_template,
        function_name="MathAssistant",
        plugin_name="MyAssistant",
        description="A math assistant that can add numbers or answer general questions."
    )

    print("--- Running Semantic Kernel Agent ---")

    # Example 1: Query that should use the MathSkill
    query1 = "What is 15 plus 7?"
    print(f"\nQuery: '{query1}'")
    # Using invoke_prompt_async for simpler calls, but planner would be used for complex chains
    # For a simple prompt function with tool calling, invoke_prompt_async is sufficient.
    result1 = await kernel.invoke_prompt_async(
        prompt=prompt_template,
        variables={"input": query1},
        function_call_behavior=kernel.auto_function_request(), # Enable auto-tool calling
    )
    print(f"SK Response: {result1}")

    # Example 2: General query
    query2 = "Tell me a fun fact about space."
    print(f"\nQuery: '{query2}'")
    result2 = await kernel.invoke_prompt_async(
        prompt=prompt_template,
        variables={"input": query2},
        function_call_behavior=kernel.auto_function_request(),
    )
    print(f"SK Response: {result2}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

# test_sk_skills.py
import pytest
import os
import asyncio
from unittest.mock import MagicMock
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function
from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase
from semantic_kernel.contents.chat_history import ChatHistory
from semantic_kernel.contents.chat_message_content import ChatMessageContent

# --- Define the MathSkill (same as in sk_debug.py) ---
class MathSkill:
    @kernel_function(
        description="Adds two numbers together.",
        name="Add",
        parameters=[
            {"name": "input", "description": "The first number to add", "type": "string", "required": True},
            {"name": "number2", "description": "The second number to add", "type": "string", "required": True},
        ],
    )
    def add(self, input: str, number2: str) -> str:
        try:
            result = float(input) + float(number2)
            return str(result)
        except ValueError:
            return "Error: Invalid numbers provided."

# --- Mock Chat Completion Service ---
# We'll create a custom mock class that mimics the ChatCompletionClientBase interface.
class MockChatCompletion(ChatCompletionClientBase):
    def __init__(self, mock_responses: dict):
        self._mock_responses = mock_responses
        self._calls = [] # To record calls for assertion

    async def get_chat_message_contents(
        self, chat_history: ChatHistory, settings=None, **kwargs
    ) -> list[ChatMessageContent]:
        # Extract the last user message to determine the mock response
        last_user_message = ""
        for message in chat_history.messages:
            if message.role.value == "user":
                last_user_message = message.content
        
        self._calls.append(last_user_message) # Record the call

        # Check if the prompt suggests tool calling or general response
        if "MyMath.Add" in last_user_message and "15" in last_user_message and "7" in last_user_message:
            # Simulate LLM deciding to call the tool
            response_content = '{"tool_calls": [{"id": "call_123", "type": "function", "function": {"name": "MyMath-Add", "arguments": "{\\"input\\": \\"15\\", \\"number2\\": \\"7\\"}"}}]}'
        elif "fun fact" in last_user_message:
            response_content = "Mock fun fact about space: It's big! TERMINATE"
        else:
            response_content = "Mock general response. TERMINATE"
        
        return [ChatMessageContent(role="assistant", content=response_content)]

    async def get_streaming_chat_message_contents(self, chat_history: ChatHistory, settings=None, **kwargs):
        # Not implemented for this test, but would yield ChatMessageContent
        yield ChatMessageContent(role="assistant", content="Mock streaming response.")

# --- Pytest fixture to provide a mocked kernel ---
@pytest.fixture
async def mocked_kernel():
    kernel = Kernel()
    
    # Instantiate our mock chat completion service
    mock_service = MockChatCompletion(mock_responses={})
    kernel.add_service(mock_service, service_id="mock_chat")
    
    # Import the real MathSkill
    kernel.import_plugin_from_object(MathSkill(), plugin_name="MyMath")

    # Define the prompt function using the mock service
    prompt_template = """
    You are a helpful assistant.
    User query: {{ $input }}

    If the query involves adding two numbers, use the MyMath.Add skill.
    Otherwise, answer generally.
    """
    math_assistant_function = kernel.create_function_from_prompt(
        prompt_template=prompt_template,
        function_name="MathAssistant",
        plugin_name="MyAssistant",
        description="A math assistant that can add numbers or answer general questions.",
        ai_service_id="mock_chat" # Crucially, tell it to use our mock service
    )

    yield kernel, mock_service # Yield both the kernel and the mock service for assertions

    # Cleanup if necessary (not strictly needed for this mock)

@pytest.mark.asyncio
async def test_sk_math_skill_invocation(mocked_kernel):
    """Test if Semantic Kernel correctly invokes the MathSkill."""
    kernel, mock_service = mocked_kernel

    query = "What is 15 plus 7?"
    result = await kernel.invoke_prompt_async(
        prompt="User query: {{ $input }}", # Only pass the user query, the prompt function handles the rest
        variables={"input": query},
        function_call_behavior=kernel.auto_function_request(),
        ai_service_id="mock_chat" # Ensure this specific call uses the mock
    )
    
    # Assert that the MathSkill was called and returned the correct value
    # The MockChatCompletion simulates the LLM outputting a tool call for MyMath.Add
    # The kernel then executes the real MathSkill.Add, and its output is returned.
    assert result == "22.0" # Expected output from MathSkill.Add

@pytest.mark.asyncio
async def test_sk_general_response(mocked_kernel):
    """Test if Semantic Kernel provides a general response when no skill is needed."""
    kernel, mock_service = mocked_kernel

    query = "Tell me a fun fact about space."
    result = await kernel.invoke_prompt_async(
        prompt="User query: {{ $input }}",
        variables={"input": query},
        function_call_behavior=kernel.auto_function_request(),
        ai_service_id="mock_chat"
    )

    # Assert the mocked general response
    assert "Mock fun fact about space" in str(result)