diff --git a/tests/structs/test_multi_agent_debate.py b/tests/structs/test_multi_agent_debate.py
new file mode 100644
index 00000000..12737b3b
--- /dev/null
+++ b/tests/structs/test_multi_agent_debate.py
@@ -0,0 +1,1097 @@
+import pytest
+from loguru import logger
+from swarms.structs.multi_agent_debates import (
+    OneOnOneDebate,
+    ExpertPanelDiscussion,
+    RoundTableDiscussion,
+    InterviewSeries,
+    PeerReviewProcess,
+    MediationSession,
+    BrainstormingSession,
+    TrialSimulation,
+    CouncilMeeting,
+    MentorshipSession,
+    NegotiationSession,
+)
+from swarms.structs.agent import Agent
+
+
+def create_function_agent(name: str, system_prompt: str = None):
+    if system_prompt is None:
+        system_prompt = f"You are {name}. Provide concise and direct responses."
+    
+    agent = Agent(
+        agent_name=name,
+        agent_description=f"Test agent {name}",
+        system_prompt=system_prompt,
+        model_name="gpt-4o-mini",
+        max_loops=1,
+        verbose=False,
+    )
+    return agent
+
+
+@pytest.fixture
+def sample_two_agents():
+    agent1 = create_function_agent(
+        "Agent1",
+        "You are Agent1. Provide concise responses."
+    )
+    agent2 = create_function_agent(
+        "Agent2",
+        "You are Agent2. Provide concise responses."
+    )
+    return [agent1, agent2]
+
+
+@pytest.fixture
+def sample_three_agents():
+    agent1 = create_function_agent("Agent1")
+    agent2 = create_function_agent("Agent2")
+    agent3 = create_function_agent("Agent3")
+    return [agent1, agent2, agent3]
+
+
+@pytest.fixture
+def sample_task():
+    return "What is 2+2?"
+
+
+def test_one_on_one_debate_initialization(sample_two_agents):
+    try:
+        assert sample_two_agents is not None
+        debate = OneOnOneDebate(
+            max_loops=2,
+            agents=sample_two_agents,
+            output_type="str-all-except-first",
+        )
+        assert debate is not None
+        assert debate.max_loops == 2
+        assert len(debate.agents) == 2
+        assert debate.output_type == "str-all-except-first"
+        logger.info("OneOnOneDebate initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test OneOnOneDebate initialization: {e}")
+        raise
+
+
+def test_one_on_one_debate_run(sample_two_agents, sample_task):
+    try:
+        assert sample_two_agents is not None
+        assert sample_task is not None
+        debate = OneOnOneDebate(
+            max_loops=2,
+            agents=sample_two_agents,
+            output_type="str-all-except-first",
+        )
+        assert debate is not None
+        result = debate.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("OneOnOneDebate run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test OneOnOneDebate run: {e}")
+        raise
+
+
+def test_one_on_one_debate_wrong_number_of_agents(sample_three_agents, sample_task):
+    try:
+        debate = OneOnOneDebate(
+            max_loops=2,
+            agents=sample_three_agents,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="exactly two agents"):
+            debate.run(sample_task)
+        logger.info("OneOnOneDebate wrong number of agents test passed")
+    except Exception as e:
+        logger.error(f"Failed to test OneOnOneDebate wrong number of agents: {e}")
+        raise
+
+
+def test_one_on_one_debate_output_types(sample_two_agents, sample_task):
+    try:
+        assert sample_two_agents is not None
+        assert sample_task is not None
+        output_types = ["str-all-except-first", "list", "dict", "str"]
+        assert output_types is not None
+        for output_type in output_types:
+            debate = OneOnOneDebate(
+                max_loops=2,
+                agents=sample_two_agents,
+                output_type=output_type,
+            )
+            assert debate is not None
+            result = debate.run(sample_task)
+            assert result is not None
+            if output_type == "list":
+                assert isinstance(result, list)
+            elif output_type == "dict":
+                assert isinstance(result, (dict, list))
+            else:
+                assert isinstance(result, str)
+        logger.info("OneOnOneDebate output types test passed")
+    except Exception as e:
+        logger.error(f"Failed to test OneOnOneDebate output types: {e}")
+        raise
+
+
+def test_one_on_one_debate_with_image(sample_two_agents):
+    try:
+        assert sample_two_agents is not None
+        task = "Analyze this image"
+        assert task is not None
+        img = "test_image.jpg"
+        assert img is not None
+        debate = OneOnOneDebate(
+            max_loops=2,
+            agents=sample_two_agents,
+            img=img,
+            output_type="str-all-except-first",
+        )
+        assert debate is not None
+        result = debate.run(task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("OneOnOneDebate with image test passed")
+    except Exception as e:
+        logger.error(f"Failed to test OneOnOneDebate with image: {e}")
+        raise
+
+
+def test_expert_panel_discussion_initialization(sample_three_agents):
+    try:
+        moderator = create_function_agent("Moderator")
+        assert moderator is not None
+        panel = ExpertPanelDiscussion(
+            max_rounds=2,
+            agents=sample_three_agents,
+            moderator=moderator,
+            output_type="str-all-except-first",
+        )
+        assert panel is not None
+        assert panel.max_rounds == 2
+        assert len(panel.agents) == 3
+        assert panel.moderator is not None
+        logger.info("ExpertPanelDiscussion initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test ExpertPanelDiscussion initialization: {e}")
+        raise
+
+
+def test_expert_panel_discussion_run(sample_three_agents, sample_task):
+    try:
+        moderator = create_function_agent("Moderator")
+        assert moderator is not None
+        panel = ExpertPanelDiscussion(
+            max_rounds=2,
+            agents=sample_three_agents,
+            moderator=moderator,
+            output_type="str-all-except-first",
+        )
+        assert panel is not None
+        result = panel.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("ExpertPanelDiscussion run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test ExpertPanelDiscussion run: {e}")
+        raise
+
+
+def test_expert_panel_discussion_insufficient_agents(sample_task):
+    try:
+        moderator = create_function_agent("Moderator")
+        assert moderator is not None
+        single_agent = [create_function_agent("Agent1")]
+        assert single_agent is not None
+        assert len(single_agent) > 0
+        assert single_agent[0] is not None
+        panel = ExpertPanelDiscussion(
+            max_rounds=2,
+            agents=single_agent,
+            moderator=moderator,
+            output_type="str-all-except-first",
+        )
+        assert panel is not None
+        with pytest.raises(ValueError, match="At least two expert agents"):
+            panel.run(sample_task)
+        logger.info("ExpertPanelDiscussion insufficient agents test passed")
+    except Exception as e:
+        logger.error(f"Failed to test ExpertPanelDiscussion insufficient agents: {e}")
+        raise
+
+
+def test_expert_panel_discussion_no_moderator(sample_three_agents, sample_task):
+    try:
+        panel = ExpertPanelDiscussion(
+            max_rounds=2,
+            agents=sample_three_agents,
+            moderator=None,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="moderator agent is required"):
+            panel.run(sample_task)
+        logger.info("ExpertPanelDiscussion no moderator test passed")
+    except Exception as e:
+        logger.error(f"Failed to test ExpertPanelDiscussion no moderator: {e}")
+        raise
+
+
+def test_round_table_discussion_initialization(sample_three_agents):
+    try:
+        facilitator = create_function_agent("Facilitator")
+        assert facilitator is not None
+        round_table = RoundTableDiscussion(
+            max_cycles=2,
+            agents=sample_three_agents,
+            facilitator=facilitator,
+            output_type="str-all-except-first",
+        )
+        assert round_table is not None
+        assert round_table.max_cycles == 2
+        assert len(round_table.agents) == 3
+        assert round_table.facilitator is not None
+        logger.info("RoundTableDiscussion initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test RoundTableDiscussion initialization: {e}")
+        raise
+
+
+def test_round_table_discussion_run(sample_three_agents, sample_task):
+    try:
+        facilitator = create_function_agent("Facilitator")
+        assert facilitator is not None
+        round_table = RoundTableDiscussion(
+            max_cycles=2,
+            agents=sample_three_agents,
+            facilitator=facilitator,
+            output_type="str-all-except-first",
+        )
+        assert round_table is not None
+        result = round_table.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("RoundTableDiscussion run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test RoundTableDiscussion run: {e}")
+        raise
+
+
+def test_round_table_discussion_insufficient_agents(sample_task):
+    try:
+        facilitator = create_function_agent("Facilitator")
+        single_agent = [create_function_agent("Agent1")]
+        round_table = RoundTableDiscussion(
+            max_cycles=2,
+            agents=single_agent,
+            facilitator=facilitator,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="At least two participants"):
+            round_table.run(sample_task)
+        logger.info("RoundTableDiscussion insufficient agents test passed")
+    except Exception as e:
+        logger.error(f"Failed to test RoundTableDiscussion insufficient agents: {e}")
+        raise
+
+
+def test_round_table_discussion_no_facilitator(sample_three_agents, sample_task):
+    try:
+        round_table = RoundTableDiscussion(
+            max_cycles=2,
+            agents=sample_three_agents,
+            facilitator=None,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="facilitator agent is required"):
+            round_table.run(sample_task)
+        logger.info("RoundTableDiscussion no facilitator test passed")
+    except Exception as e:
+        logger.error(f"Failed to test RoundTableDiscussion no facilitator: {e}")
+        raise
+
+
+def test_interview_series_initialization():
+    try:
+        interviewer = create_function_agent("Interviewer")
+        assert interviewer is not None
+        interviewee = create_function_agent("Interviewee")
+        assert interviewee is not None
+        questions = ["Question 1", "Question 2"]
+        assert questions is not None
+        interview = InterviewSeries(
+            questions=questions,
+            interviewer=interviewer,
+            interviewee=interviewee,
+            follow_up_depth=1,
+            output_type="str-all-except-first",
+        )
+        assert interview is not None
+        assert interview.questions == questions
+        assert interview.interviewer is not None
+        assert interview.interviewee is not None
+        assert interview.follow_up_depth == 1
+        logger.info("InterviewSeries initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test InterviewSeries initialization: {e}")
+        raise
+
+
+def test_interview_series_run(sample_task):
+    try:
+        interviewer = create_function_agent("Interviewer")
+        assert interviewer is not None
+        interviewee = create_function_agent("Interviewee")
+        assert interviewee is not None
+        questions = ["Question 1", "Question 2"]
+        assert questions is not None
+        interview = InterviewSeries(
+            questions=questions,
+            interviewer=interviewer,
+            interviewee=interviewee,
+            follow_up_depth=1,
+            output_type="str-all-except-first",
+        )
+        assert interview is not None
+        result = interview.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("InterviewSeries run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test InterviewSeries run: {e}")
+        raise
+
+
+def test_interview_series_no_interviewer(sample_task):
+    try:
+        interviewee = create_function_agent("Interviewee")
+        interview = InterviewSeries(
+            questions=["Question 1"],
+            interviewer=None,
+            interviewee=interviewee,
+            follow_up_depth=1,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="Both interviewer and interviewee"):
+            interview.run(sample_task)
+        logger.info("InterviewSeries no interviewer test passed")
+    except Exception as e:
+        logger.error(f"Failed to test InterviewSeries no interviewer: {e}")
+        raise
+
+
+def test_interview_series_no_interviewee(sample_task):
+    try:
+        interviewer = create_function_agent("Interviewer")
+        interview = InterviewSeries(
+            questions=["Question 1"],
+            interviewer=interviewer,
+            interviewee=None,
+            follow_up_depth=1,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="Both interviewer and interviewee"):
+            interview.run(sample_task)
+        logger.info("InterviewSeries no interviewee test passed")
+    except Exception as e:
+        logger.error(f"Failed to test InterviewSeries no interviewee: {e}")
+        raise
+
+
+def test_interview_series_default_questions(sample_task):
+    try:
+        interviewer = create_function_agent("Interviewer")
+        assert interviewer is not None
+        interviewee = create_function_agent("Interviewee")
+        assert interviewee is not None
+        assert sample_task is not None
+        interview = InterviewSeries(
+            questions=None,
+            interviewer=interviewer,
+            interviewee=interviewee,
+            follow_up_depth=1,
+            output_type="str-all-except-first",
+        )
+        assert interview is not None
+        result = interview.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("InterviewSeries default questions test passed")
+    except Exception as e:
+        logger.error(f"Failed to test InterviewSeries default questions: {e}")
+        raise
+
+
+def test_peer_review_process_initialization():
+    try:
+        reviewers = [create_function_agent("Reviewer1"), create_function_agent("Reviewer2")]
+        assert reviewers is not None
+        assert len(reviewers) == 2
+        assert reviewers[0] is not None
+        assert reviewers[1] is not None
+        author = create_function_agent("Author")
+        assert author is not None
+        peer_review = PeerReviewProcess(
+            reviewers=reviewers,
+            author=author,
+            review_rounds=2,
+            output_type="str-all-except-first",
+        )
+        assert peer_review is not None
+        assert len(peer_review.reviewers) == 2
+        assert peer_review.author is not None
+        assert peer_review.review_rounds == 2
+        logger.info("PeerReviewProcess initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test PeerReviewProcess initialization: {e}")
+        raise
+
+
+def test_peer_review_process_run(sample_task):
+    try:
+        reviewers = [create_function_agent("Reviewer1"), create_function_agent("Reviewer2")]
+        assert reviewers is not None
+        assert len(reviewers) == 2
+        author = create_function_agent("Author")
+        assert author is not None
+        peer_review = PeerReviewProcess(
+            reviewers=reviewers,
+            author=author,
+            review_rounds=2,
+            output_type="str-all-except-first",
+        )
+        assert peer_review is not None
+        result = peer_review.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("PeerReviewProcess run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test PeerReviewProcess run: {e}")
+        raise
+
+
+def test_peer_review_process_no_reviewers(sample_task):
+    try:
+        author = create_function_agent("Author")
+        peer_review = PeerReviewProcess(
+            reviewers=[],
+            author=author,
+            review_rounds=2,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="At least one reviewer"):
+            peer_review.run(sample_task)
+        logger.info("PeerReviewProcess no reviewers test passed")
+    except Exception as e:
+        logger.error(f"Failed to test PeerReviewProcess no reviewers: {e}")
+        raise
+
+
+def test_peer_review_process_no_author(sample_task):
+    try:
+        reviewers = [create_function_agent("Reviewer1")]
+        peer_review = PeerReviewProcess(
+            reviewers=reviewers,
+            author=None,
+            review_rounds=2,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="author agent is required"):
+            peer_review.run(sample_task)
+        logger.info("PeerReviewProcess no author test passed")
+    except Exception as e:
+        logger.error(f"Failed to test PeerReviewProcess no author: {e}")
+        raise
+
+
+def test_mediation_session_initialization(sample_two_agents):
+    try:
+        mediator = create_function_agent("Mediator")
+        assert mediator is not None
+        assert sample_two_agents is not None
+        mediation = MediationSession(
+            parties=sample_two_agents,
+            mediator=mediator,
+            max_sessions=2,
+            output_type="str-all-except-first",
+        )
+        assert mediation is not None
+        assert len(mediation.parties) == 2
+        assert mediation.mediator is not None
+        assert mediation.max_sessions == 2
+        logger.info("MediationSession initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test MediationSession initialization: {e}")
+        raise
+
+
+def test_mediation_session_run(sample_two_agents, sample_task):
+    try:
+        mediator = create_function_agent("Mediator")
+        assert mediator is not None
+        assert sample_two_agents is not None
+        mediation = MediationSession(
+            parties=sample_two_agents,
+            mediator=mediator,
+            max_sessions=2,
+            output_type="str-all-except-first",
+        )
+        assert mediation is not None
+        result = mediation.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("MediationSession run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test MediationSession run: {e}")
+        raise
+
+
+def test_mediation_session_insufficient_parties(sample_task):
+    try:
+        mediator = create_function_agent("Mediator")
+        single_party = [create_function_agent("Party1")]
+        mediation = MediationSession(
+            parties=single_party,
+            mediator=mediator,
+            max_sessions=2,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="At least two parties"):
+            mediation.run(sample_task)
+        logger.info("MediationSession insufficient parties test passed")
+    except Exception as e:
+        logger.error(f"Failed to test MediationSession insufficient parties: {e}")
+        raise
+
+
+def test_mediation_session_no_mediator(sample_two_agents, sample_task):
+    try:
+        mediation = MediationSession(
+            parties=sample_two_agents,
+            mediator=None,
+            max_sessions=2,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="mediator agent is required"):
+            mediation.run(sample_task)
+        logger.info("MediationSession no mediator test passed")
+    except Exception as e:
+        logger.error(f"Failed to test MediationSession no mediator: {e}")
+        raise
+
+
+def test_brainstorming_session_initialization(sample_three_agents):
+    try:
+        facilitator = create_function_agent("Facilitator")
+        assert facilitator is not None
+        assert sample_three_agents is not None
+        brainstorming = BrainstormingSession(
+            participants=sample_three_agents,
+            facilitator=facilitator,
+            idea_rounds=2,
+            build_on_ideas=True,
+            output_type="str-all-except-first",
+        )
+        assert brainstorming is not None
+        assert len(brainstorming.participants) == 3
+        assert brainstorming.facilitator is not None
+        assert brainstorming.idea_rounds == 2
+        assert brainstorming.build_on_ideas is True
+        logger.info("BrainstormingSession initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test BrainstormingSession initialization: {e}")
+        raise
+
+
+def test_brainstorming_session_run(sample_three_agents, sample_task):
+    try:
+        facilitator = create_function_agent("Facilitator")
+        assert facilitator is not None
+        assert sample_three_agents is not None
+        brainstorming = BrainstormingSession(
+            participants=sample_three_agents,
+            facilitator=facilitator,
+            idea_rounds=2,
+            build_on_ideas=True,
+            output_type="str-all-except-first",
+        )
+        assert brainstorming is not None
+        result = brainstorming.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("BrainstormingSession run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test BrainstormingSession run: {e}")
+        raise
+
+
+def test_brainstorming_session_insufficient_participants(sample_task):
+    try:
+        facilitator = create_function_agent("Facilitator")
+        single_participant = [create_function_agent("Participant1")]
+        brainstorming = BrainstormingSession(
+            participants=single_participant,
+            facilitator=facilitator,
+            idea_rounds=2,
+            build_on_ideas=True,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="At least two participants"):
+            brainstorming.run(sample_task)
+        logger.info("BrainstormingSession insufficient participants test passed")
+    except Exception as e:
+        logger.error(f"Failed to test BrainstormingSession insufficient participants: {e}")
+        raise
+
+
+def test_brainstorming_session_no_facilitator(sample_three_agents, sample_task):
+    try:
+        brainstorming = BrainstormingSession(
+            participants=sample_three_agents,
+            facilitator=None,
+            idea_rounds=2,
+            build_on_ideas=True,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="facilitator agent is required"):
+            brainstorming.run(sample_task)
+        logger.info("BrainstormingSession no facilitator test passed")
+    except Exception as e:
+        logger.error(f"Failed to test BrainstormingSession no facilitator: {e}")
+        raise
+
+
+def test_trial_simulation_initialization():
+    try:
+        prosecution = create_function_agent("Prosecution")
+        assert prosecution is not None
+        defense = create_function_agent("Defense")
+        assert defense is not None
+        judge = create_function_agent("Judge")
+        assert judge is not None
+        witnesses = [create_function_agent("Witness1")]
+        assert witnesses is not None
+        assert len(witnesses) == 1
+        assert witnesses[0] is not None
+        trial = TrialSimulation(
+            prosecution=prosecution,
+            defense=defense,
+            judge=judge,
+            witnesses=witnesses,
+            phases=["opening", "closing"],
+            output_type="str-all-except-first",
+        )
+        assert trial is not None
+        assert trial.prosecution is not None
+        assert trial.defense is not None
+        assert trial.judge is not None
+        assert len(trial.witnesses) == 1
+        assert trial.phases == ["opening", "closing"]
+        logger.info("TrialSimulation initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test TrialSimulation initialization: {e}")
+        raise
+
+
+def test_trial_simulation_run(sample_task):
+    try:
+        prosecution = create_function_agent("Prosecution")
+        assert prosecution is not None
+        defense = create_function_agent("Defense")
+        assert defense is not None
+        judge = create_function_agent("Judge")
+        assert judge is not None
+        trial = TrialSimulation(
+            prosecution=prosecution,
+            defense=defense,
+            judge=judge,
+            witnesses=None,
+            phases=["opening", "closing"],
+            output_type="str-all-except-first",
+        )
+        assert trial is not None
+        result = trial.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("TrialSimulation run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test TrialSimulation run: {e}")
+        raise
+
+
+def test_trial_simulation_no_prosecution(sample_task):
+    try:
+        defense = create_function_agent("Defense")
+        judge = create_function_agent("Judge")
+        trial = TrialSimulation(
+            prosecution=None,
+            defense=defense,
+            judge=judge,
+            witnesses=None,
+            phases=["opening"],
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="all required"):
+            trial.run(sample_task)
+        logger.info("TrialSimulation no prosecution test passed")
+    except Exception as e:
+        logger.error(f"Failed to test TrialSimulation no prosecution: {e}")
+        raise
+
+
+def test_trial_simulation_default_phases(sample_task):
+    try:
+        prosecution = create_function_agent("Prosecution")
+        assert prosecution is not None
+        defense = create_function_agent("Defense")
+        assert defense is not None
+        judge = create_function_agent("Judge")
+        assert judge is not None
+        assert sample_task is not None
+        trial = TrialSimulation(
+            prosecution=prosecution,
+            defense=defense,
+            judge=judge,
+            witnesses=None,
+            phases=None,
+            output_type="str-all-except-first",
+        )
+        assert trial is not None
+        result = trial.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("TrialSimulation default phases test passed")
+    except Exception as e:
+        logger.error(f"Failed to test TrialSimulation default phases: {e}")
+        raise
+
+
+def test_council_meeting_initialization(sample_three_agents):
+    try:
+        chairperson = create_function_agent("Chairperson")
+        assert chairperson is not None
+        assert sample_three_agents is not None
+        council = CouncilMeeting(
+            council_members=sample_three_agents,
+            chairperson=chairperson,
+            voting_rounds=2,
+            require_consensus=False,
+            output_type="str-all-except-first",
+        )
+        assert council is not None
+        assert len(council.council_members) == 3
+        assert council.chairperson is not None
+        assert council.voting_rounds == 2
+        assert council.require_consensus is False
+        logger.info("CouncilMeeting initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test CouncilMeeting initialization: {e}")
+        raise
+
+
+def test_council_meeting_run(sample_three_agents, sample_task):
+    try:
+        chairperson = create_function_agent("Chairperson")
+        assert chairperson is not None
+        assert sample_three_agents is not None
+        council = CouncilMeeting(
+            council_members=sample_three_agents,
+            chairperson=chairperson,
+            voting_rounds=1,
+            require_consensus=False,
+            output_type="str-all-except-first",
+        )
+        assert council is not None
+        result = council.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("CouncilMeeting run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test CouncilMeeting run: {e}")
+        raise
+
+
+def test_council_meeting_insufficient_members(sample_task):
+    try:
+        chairperson = create_function_agent("Chairperson")
+        single_member = [create_function_agent("Member1")]
+        council = CouncilMeeting(
+            council_members=single_member,
+            chairperson=chairperson,
+            voting_rounds=1,
+            require_consensus=False,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="At least two council members"):
+            council.run(sample_task)
+        logger.info("CouncilMeeting insufficient members test passed")
+    except Exception as e:
+        logger.error(f"Failed to test CouncilMeeting insufficient members: {e}")
+        raise
+
+
+def test_council_meeting_no_chairperson(sample_three_agents, sample_task):
+    try:
+        council = CouncilMeeting(
+            council_members=sample_three_agents,
+            chairperson=None,
+            voting_rounds=1,
+            require_consensus=False,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="chairperson agent is required"):
+            council.run(sample_task)
+        logger.info("CouncilMeeting no chairperson test passed")
+    except Exception as e:
+        logger.error(f"Failed to test CouncilMeeting no chairperson: {e}")
+        raise
+
+
+def test_mentorship_session_initialization():
+    try:
+        mentor = create_function_agent("Mentor")
+        assert mentor is not None
+        mentee = create_function_agent("Mentee")
+        assert mentee is not None
+        mentorship = MentorshipSession(
+            mentor=mentor,
+            mentee=mentee,
+            session_count=2,
+            include_feedback=True,
+            output_type="str-all-except-first",
+        )
+        assert mentorship is not None
+        assert mentorship.mentor is not None
+        assert mentorship.mentee is not None
+        assert mentorship.session_count == 2
+        assert mentorship.include_feedback is True
+        logger.info("MentorshipSession initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test MentorshipSession initialization: {e}")
+        raise
+
+
+def test_mentorship_session_run(sample_task):
+    try:
+        mentor = create_function_agent("Mentor")
+        assert mentor is not None
+        mentee = create_function_agent("Mentee")
+        assert mentee is not None
+        mentorship = MentorshipSession(
+            mentor=mentor,
+            mentee=mentee,
+            session_count=2,
+            include_feedback=True,
+            output_type="str-all-except-first",
+        )
+        assert mentorship is not None
+        result = mentorship.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("MentorshipSession run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test MentorshipSession run: {e}")
+        raise
+
+
+def test_mentorship_session_no_mentor(sample_task):
+    try:
+        mentee = create_function_agent("Mentee")
+        mentorship = MentorshipSession(
+            mentor=None,
+            mentee=mentee,
+            session_count=2,
+            include_feedback=True,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="Both mentor and mentee"):
+            mentorship.run(sample_task)
+        logger.info("MentorshipSession no mentor test passed")
+    except Exception as e:
+        logger.error(f"Failed to test MentorshipSession no mentor: {e}")
+        raise
+
+
+def test_mentorship_session_no_mentee(sample_task):
+    try:
+        mentor = create_function_agent("Mentor")
+        mentorship = MentorshipSession(
+            mentor=mentor,
+            mentee=None,
+            session_count=2,
+            include_feedback=True,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="Both mentor and mentee"):
+            mentorship.run(sample_task)
+        logger.info("MentorshipSession no mentee test passed")
+    except Exception as e:
+        logger.error(f"Failed to test MentorshipSession no mentee: {e}")
+        raise
+
+
+def test_negotiation_session_initialization(sample_two_agents):
+    try:
+        mediator = create_function_agent("Mediator")
+        assert mediator is not None
+        assert sample_two_agents is not None
+        negotiation = NegotiationSession(
+            parties=sample_two_agents,
+            mediator=mediator,
+            negotiation_rounds=3,
+            include_concessions=True,
+            output_type="str-all-except-first",
+        )
+        assert negotiation is not None
+        assert len(negotiation.parties) == 2
+        assert negotiation.mediator is not None
+        assert negotiation.negotiation_rounds == 3
+        assert negotiation.include_concessions is True
+        logger.info("NegotiationSession initialization test passed")
+    except Exception as e:
+        logger.error(f"Failed to test NegotiationSession initialization: {e}")
+        raise
+
+
+def test_negotiation_session_run(sample_two_agents, sample_task):
+    try:
+        mediator = create_function_agent("Mediator")
+        assert mediator is not None
+        assert sample_two_agents is not None
+        negotiation = NegotiationSession(
+            parties=sample_two_agents,
+            mediator=mediator,
+            negotiation_rounds=2,
+            include_concessions=True,
+            output_type="str-all-except-first",
+        )
+        assert negotiation is not None
+        result = negotiation.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("NegotiationSession run test passed")
+    except Exception as e:
+        logger.error(f"Failed to test NegotiationSession run: {e}")
+        raise
+
+
+def test_negotiation_session_insufficient_parties(sample_task):
+    try:
+        mediator = create_function_agent("Mediator")
+        single_party = [create_function_agent("Party1")]
+        negotiation = NegotiationSession(
+            parties=single_party,
+            mediator=mediator,
+            negotiation_rounds=2,
+            include_concessions=True,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="At least two parties"):
+            negotiation.run(sample_task)
+        logger.info("NegotiationSession insufficient parties test passed")
+    except Exception as e:
+        logger.error(f"Failed to test NegotiationSession insufficient parties: {e}")
+        raise
+
+
+def test_negotiation_session_no_mediator(sample_two_agents, sample_task):
+    try:
+        negotiation = NegotiationSession(
+            parties=sample_two_agents,
+            mediator=None,
+            negotiation_rounds=2,
+            include_concessions=True,
+            output_type="str-all-except-first",
+        )
+        with pytest.raises(ValueError, match="mediator agent is required"):
+            negotiation.run(sample_task)
+        logger.info("NegotiationSession no mediator test passed")
+    except Exception as e:
+        logger.error(f"Failed to test NegotiationSession no mediator: {e}")
+        raise
+
+
+def test_negotiation_session_without_concessions(sample_two_agents, sample_task):
+    try:
+        mediator = create_function_agent("Mediator")
+        assert mediator is not None
+        assert sample_two_agents is not None
+        negotiation = NegotiationSession(
+            parties=sample_two_agents,
+            mediator=mediator,
+            negotiation_rounds=2,
+            include_concessions=False,
+            output_type="str-all-except-first",
+        )
+        assert negotiation is not None
+        result = negotiation.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("NegotiationSession without concessions test passed")
+    except Exception as e:
+        logger.error(f"Failed to test NegotiationSession without concessions: {e}")
+        raise
+
+
+def test_one_on_one_debate_multiple_loops(sample_two_agents, sample_task):
+    try:
+        assert sample_two_agents is not None
+        debate = OneOnOneDebate(
+            max_loops=5,
+            agents=sample_two_agents,
+            output_type="str-all-except-first",
+        )
+        assert debate is not None
+        result = debate.run(sample_task)
+        assert result is not None
+        assert isinstance(result, str)
+        assert len(result) >= 0
+        logger.info("OneOnOneDebate multiple loops test passed")
+    except Exception as e:
+        logger.error(f"Failed to test OneOnOneDebate multiple loops: {e}")
+        raise
+
+
+def test_expert_panel_discussion_output_types(sample_three_agents, sample_task):
+    try:
+        moderator = create_function_agent("Moderator")
+        assert moderator is not None
+        assert sample_three_agents is not None
+        output_types = ["str-all-except-first", "list", "dict", "str"]
+        assert output_types is not None
+        for output_type in output_types:
+            panel = ExpertPanelDiscussion(
+                max_rounds=1,
+                agents=sample_three_agents,
+                moderator=moderator,
+                output_type=output_type,
+            )
+            assert panel is not None
+            result = panel.run(sample_task)
+            assert result is not None
+            if output_type == "list":
+                assert isinstance(result, list)
+            elif output_type == "dict":
+                assert isinstance(result, (dict, list))
+            else:
+                assert isinstance(result, str)
+        logger.info("ExpertPanelDiscussion output types test passed")
+    except Exception as e:
+        logger.error(f"Failed to test ExpertPanelDiscussion output types: {e}")
+        raise
\ No newline at end of file