swarms 7.9.0__py3-none-any.whl → 7.9.1__py3-none-any.whl

swarms/structs/interactive_groupchat.py

@@ -121,6 +121,71 @@ def priority_speaker(
     return available_agents[-1]  # Fallback
 
 
+def random_dynamic_speaker(
+    agents: List[str],
+    response: str = "",
+    strategy: str = "parallel",
+    **kwargs,
+) -> Union[str, List[str]]:
+    """
+    Random dynamic speaker function that selects agents based on @mentions in responses.
+
+    This function works in two phases:
+    1. If no response is provided (first call), randomly selects an agent
+    2. If a response is provided, extracts @mentions and returns agent(s) based on strategy
+
+    Args:
+        agents: List of available agent names
+        response: The response from the previous agent (may contain @mentions)
+        strategy: How to handle multiple mentions - "sequential" or "parallel"
+        **kwargs: Additional arguments (ignored)
+
+    Returns:
+        For sequential strategy: str (single agent name)
+        For parallel strategy: List[str] (list of agent names)
+    """
+    if not agents:
+        raise ValueError(
+            "No agents provided for random dynamic selection"
+        )
+
+    # If no response provided, randomly select first agent
+    if not response:
+        return random.choice(agents)
+
+    # Extract @mentions from the response
+    mentions = re.findall(r"@(\w+)", response)
+
+    # Filter mentions to only include valid agents
+    valid_mentions = [
+        mention for mention in mentions if mention in agents
+    ]
+
+    if not valid_mentions:
+        # If no valid mentions, randomly select from all agents
+        return random.choice(agents)
+
+    # Handle multiple mentions based on strategy
+    if strategy == "sequential":
+        # Return the first mentioned agent for sequential execution
+        return valid_mentions[0]
+    elif strategy == "parallel":
+        # Return all mentioned agents for parallel execution
+        return valid_mentions
+    else:
+        raise ValueError(
+            f"Invalid strategy: {strategy}. Must be 'sequential' or 'parallel'"
+        )
+
+
+speaker_functions = {
+    "round-robin-speaker": round_robin_speaker,
+    "random-speaker": random_speaker,
+    "priority-speaker": priority_speaker,
+    "random-dynamic-speaker": random_dynamic_speaker,
+}
+
+
 class InteractiveGroupChat:
     """
     An interactive group chat system that enables conversations with multiple agents using @mentions.
@@ -145,11 +210,38 @@ class InteractiveGroupChat:
         max_loops (int, optional): Maximum conversation turns. Defaults to 1.
         output_type (str, optional): Type of output format. Defaults to "string".
         interactive (bool, optional): Whether to enable interactive terminal mode. Defaults to False.
-        speaker_function (Callable, optional): Function to determine speaking order. Defaults to round_robin_speaker.
+        speaker_function (Union[str, Callable], optional): Function to determine speaking order. Can be:
+            - A string name: "round-robin-speaker", "random-speaker", "priority-speaker", "random-dynamic-speaker"
+            - A custom callable function
+            - None (defaults to round_robin_speaker)
         speaker_state (dict, optional): Initial state for speaker function. Defaults to empty dict.
 
     Raises:
         ValueError: If invalid initialization parameters are provided
+        InvalidSpeakerFunctionError: If the speaker function is invalid
+
+    Examples:
+        # Initialize with string-based speaker function
+        group_chat = InteractiveGroupChat(
+            agents=[agent1, agent2, agent3],
+            speaker_function="random-speaker"
+        )
+
+        # Initialize with priority speaker function
+        group_chat = InteractiveGroupChat(
+            agents=[agent1, agent2, agent3],
+            speaker_function="priority-speaker",
+            speaker_state={"priorities": {"agent1": 3, "agent2": 2, "agent3": 1}}
+        )
+
+        # Initialize with dynamic speaker function (agents mention each other)
+        group_chat = InteractiveGroupChat(
+            agents=[agent1, agent2, agent3],
+            speaker_function="random-dynamic-speaker"
+        )
+
+        # Change speaker function during runtime
+        group_chat.set_speaker_function("round-robin-speaker")
     """
 
     def __init__(
@@ -161,7 +253,7 @@ class InteractiveGroupChat:
         max_loops: int = 1,
         output_type: str = "string",
         interactive: bool = False,
-        speaker_function: Optional[Callable] = None,
+        speaker_function: Optional[Union[str, Callable]] = None,
         speaker_state: Optional[dict] = None,
     ):
         self.id = id
@@ -173,9 +265,27 @@ class InteractiveGroupChat:
         self.interactive = interactive
 
         # Speaker function configuration
-        self.speaker_function = (
-            speaker_function or round_robin_speaker
-        )
+        if speaker_function is None:
+            self.speaker_function = round_robin_speaker
+        elif isinstance(speaker_function, str):
+            if speaker_function not in speaker_functions:
+                available_functions = ", ".join(
+                    speaker_functions.keys()
+                )
+                raise InvalidSpeakerFunctionError(
+                    f"Invalid speaker function: '{speaker_function}'. "
+                    f"Available functions: {available_functions}"
+                )
+            self.speaker_function = speaker_functions[
+                speaker_function
+            ]
+        elif callable(speaker_function):
+            self.speaker_function = speaker_function
+        else:
+            raise InvalidSpeakerFunctionError(
+                "Speaker function must be either a string, callable, or None"
+            )
+
         self.speaker_state = speaker_state or {"current_index": 0}
 
         # Validate speaker function
@@ -197,6 +307,230 @@ class InteractiveGroupChat:
         self._setup_conversation_context()
         self._update_agent_prompts()
 
+    def set_speaker_function(
+        self,
+        speaker_function: Union[str, Callable],
+        speaker_state: Optional[dict] = None,
+    ) -> None:
+        """
+        Set the speaker function using either a string name or a custom callable.
+
+        Args:
+            speaker_function: Either a string name of a predefined function or a custom callable
+                String options:
+                - "round-robin-speaker": Cycles through agents in order
+                - "random-speaker": Selects agents randomly
+                - "priority-speaker": Selects based on priority weights
+                - "random-dynamic-speaker": Randomly selects first agent, then follows @mentions in responses
+                Callable: Custom function that takes (agents: List[str], **kwargs) -> str
+            speaker_state: Optional state for the speaker function
+
+        Raises:
+            InvalidSpeakerFunctionError: If the speaker function is invalid
+        """
+        if isinstance(speaker_function, str):
+            # Handle string-based speaker function
+            if speaker_function not in speaker_functions:
+                available_functions = ", ".join(
+                    speaker_functions.keys()
+                )
+                raise InvalidSpeakerFunctionError(
+                    f"Invalid speaker function: '{speaker_function}'. "
+                    f"Available functions: {available_functions}"
+                )
+            self.speaker_function = speaker_functions[
+                speaker_function
+            ]
+            logger.info(
+                f"Speaker function set to: {speaker_function}"
+            )
+        elif callable(speaker_function):
+            # Handle callable speaker function
+            self.speaker_function = speaker_function
+            logger.info(
+                f"Custom speaker function set to: {speaker_function.__name__}"
+            )
+        else:
+            raise InvalidSpeakerFunctionError(
+                "Speaker function must be either a string or a callable"
+            )
+
+        # Update speaker state if provided
+        if speaker_state:
+            self.speaker_state.update(speaker_state)
+
+        # Validate the speaker function
+        self._validate_speaker_function()
+
+    def set_priorities(self, priorities: dict) -> None:
+        """
+        Set agent priorities for priority-based speaking order.
+
+        Args:
+            priorities: Dictionary mapping agent names to priority weights
+        """
+        self.speaker_state["priorities"] = priorities
+        logger.info(f"Agent priorities set: {priorities}")
+
+    def get_available_speaker_functions(self) -> List[str]:
+        """
+        Get a list of available speaker function names.
+
+        Returns:
+            List[str]: List of available speaker function names
+        """
+        return list(speaker_functions.keys())
+
+    def get_current_speaker_function(self) -> str:
+        """
+        Get the name of the current speaker function.
+
+        Returns:
+            str: Name of the current speaker function, or "custom" if it's a custom function
+        """
+        for name, func in speaker_functions.items():
+            if self.speaker_function == func:
+                return name
+        return "custom"
+
+    def start_interactive_session(self):
+        """
+        Start an interactive terminal session for chatting with agents.
+
+        This method creates a REPL (Read-Eval-Print Loop) that allows users to:
+        - Chat with agents using @mentions
+        - See available agents and their descriptions
+        - Exit the session using 'exit' or 'quit'
+        - Get help using 'help' or '?'
+        """
+        if not self.interactive:
+            raise InteractiveGroupChatError(
+                "Interactive mode is not enabled. Initialize with interactive=True"
+            )
+
+        print(f"\nWelcome to {self.name}!")
+        print(f"Description: {self.description}")
+        print(
+            f"Current speaker function: {self.get_current_speaker_function()}"
+        )
+        print("\nAvailable agents:")
+        for name, agent in self.agent_map.items():
+            if isinstance(agent, Agent):
+                print(
+                    f"- @{name}: {agent.system_prompt.splitlines()[0]}"
+                )
+            else:
+                print(f"- @{name}: Custom callable function")
+
+        print("\nCommands:")
+        print("- Type 'help' or '?' for help")
+        print("- Type 'exit' or 'quit' to end the session")
+        print("- Type 'speaker' to change speaker function")
+        print("- Use @agent_name to mention agents")
+        print("\nStart chatting:")
+
+        while True:
+            try:
+                # Get user input
+                user_input = input("\nYou: ").strip()
+
+                # Handle special commands
+                if user_input.lower() in ["exit", "quit"]:
+                    print("Goodbye!")
+                    break
+
+                if user_input.lower() in ["help", "?"]:
+                    print("\nHelp:")
+                    print("1. Mention agents using @agent_name")
+                    print(
+                        "2. You can mention multiple agents in one task"
+                    )
+                    print("3. Available agents:")
+                    for name in self.agent_map:
+                        print(f"   - @{name}")
+                    print(
+                        "4. Type 'speaker' to change speaker function"
+                    )
+                    print(
+                        "5. Type 'exit' or 'quit' to end the session"
+                    )
+                    continue
+
+                if user_input.lower() == "speaker":
+                    print(
+                        f"\nCurrent speaker function: {self.get_current_speaker_function()}"
+                    )
+                    print("Available speaker functions:")
+                    for i, func_name in enumerate(
+                        self.get_available_speaker_functions(), 1
+                    ):
+                        print(f"  {i}. {func_name}")
+
+                    try:
+                        choice = input(
+                            "\nEnter the number or name of the speaker function: "
+                        ).strip()
+
+                        # Try to parse as number first
+                        try:
+                            func_index = int(choice) - 1
+                            if (
+                                0
+                                <= func_index
+                                < len(
+                                    self.get_available_speaker_functions()
+                                )
+                            ):
+                                selected_func = self.get_available_speaker_functions()[
+                                    func_index
+                                ]
+                            else:
+                                print(
+                                    "Invalid number. Please try again."
+                                )
+                                continue
+                        except ValueError:
+                            # Try to parse as name
+                            selected_func = choice
+
+                        self.set_speaker_function(selected_func)
+                        print(
+                            f"Speaker function changed to: {self.get_current_speaker_function()}"
+                        )
+
+                    except InvalidSpeakerFunctionError as e:
+                        print(f"Error: {e}")
+                    except Exception as e:
+                        print(f"An error occurred: {e}")
+                    continue
+
+                if not user_input:
+                    continue
+
+                # Process the task and get responses
+                try:
+                    self.run(user_input)
+                    print("\nChat:")
+                    # print(response)
+
+                except NoMentionedAgentsError:
+                    print(
+                        "\nError: Please mention at least one agent using @agent_name"
+                    )
+                except AgentNotFoundError as e:
+                    print(f"\nError: {str(e)}")
+                except Exception as e:
+                    print(f"\nAn error occurred: {str(e)}")
+
+            except KeyboardInterrupt:
+                print("\nSession terminated by user. Goodbye!")
+                break
+            except Exception as e:
+                print(f"\nAn unexpected error occurred: {str(e)}")
+                print(
+                    "The session will continue. You can type 'exit' to end it."
+                )
+
     def _validate_speaker_function(self) -> None:
         """
         Validates the speaker function.
@@ -287,6 +621,7 @@ IMPORTANT: You are part of a collaborative group chat where you can interact wit
 2. ACKNOWLEDGE: Reference and acknowledge what other agents have said
 3. BUILD UPON: Add your perspective while building upon their insights
 4. MENTION: Use @agent_name to call on other agents when needed
+5. COMPLETE: Acknowledge when your part is done and what still needs to be done
 
 HOW TO MENTION OTHER AGENTS:
 - Use @agent_name to mention another agent in your response
@@ -325,24 +660,33 @@ COLLABORATION GUIDELINES:
 - ASK CLARIFYING QUESTIONS if you need more information from other agents
 - DELEGATE appropriately: "Let me ask @expert_agent to verify this" or "@specialist, can you elaborate on this point?"
 
+TASK COMPLETION GUIDELINES:
+- ACKNOWLEDGE when you are done with your part of the task
+- CLEARLY STATE what still needs to be done before the overall task is finished
+- If you mention other agents, explain what specific input you need from them
+- Use phrases like "I have completed [specific part]" or "The task still requires [specific actions]"
+- Provide a clear status update: "My analysis is complete. The task now needs @writer to create content and @reviewer to validate the approach."
+
 RESPONSE STRUCTURE:
 1. ACKNOWLEDGE: "I've reviewed the responses from @agent1 and @agent2..."
 2. BUILD: "Building on @agent1's analysis of the data..."
 3. CONTRIBUTE: "From my perspective, I would add..."
 4. COLLABORATE: "To get a complete picture, let me ask @agent3 to..."
-5. SYNTHESIZE: "Combining our insights, the key findings are..."
+5. COMPLETE: "I have completed [my part]. The task still requires [specific next steps]"
+6. SYNTHESIZE: "Combining our insights, the key findings are..."
 
 EXAMPLES OF GOOD COLLABORATION:
-- "I've reviewed @analyst's data analysis and @researcher's market insights. The data shows strong growth potential, and I agree with @researcher that we should focus on emerging markets. Let me add that from a content perspective, we should @writer to create targeted messaging for these markets."
-- "Building on @researcher's findings about customer behavior, I can see that @analyst's data supports this trend. To get a complete understanding, let me ask @writer to help us craft messaging that addresses these specific customer needs."
+- "I've reviewed @analyst's data analysis and @researcher's market insights. The data shows strong growth potential, and I agree with @researcher that we should focus on emerging markets. Let me add that from a content perspective, we should @writer to create targeted messaging for these markets. I have completed my market analysis. The task now requires @writer to develop content and @reviewer to validate our approach."
+- "Building on @researcher's findings about customer behavior, I can see that @analyst's data supports this trend. To get a complete understanding, let me ask @writer to help us craft messaging that addresses these specific customer needs. My data analysis is complete. The task still needs @writer to create messaging and @reviewer to approve the final strategy."
 
 AVOID:
 - Ignoring other agents' responses
 - Repeating what others have already said
 - Making assumptions without consulting relevant experts
 - Responding in isolation without considering the group's collective knowledge
+- Not acknowledging task completion status
 
-Remember: You are part of a team. Your response should reflect that you've read, understood, and built upon the contributions of others.
+Remember: You are part of a team. Your response should reflect that you've read, understood, and are building upon the contributions of others, and clearly communicate your task completion status.
 """
 
                 # Update the agent's system prompt
@@ -438,6 +782,12 @@ Remember: You are part of a team. Your response should reflect that you've read,
                 )
                 return sorted_agents
 
+            elif self.speaker_function == random_dynamic_speaker:
+                # For dynamic speaker, we need to handle it differently
+                # The dynamic speaker will be called during the run method
+                # For now, just return the original order
+                return mentioned_agents
+
             else:
                 # Custom speaker function
                 # For custom functions, we'll use the first agent returned
@@ -460,120 +810,12 @@ Remember: You are part of a team. Your response should reflect that you've read,
             # Fallback to original order
             return mentioned_agents
 
-    def set_speaker_function(
+    def run(
         self,
-        speaker_function: Callable,
-        speaker_state: Optional[dict] = None,
-    ) -> None:
-        """
-        Set a custom speaker function and optional state.
-
-        Args:
-            speaker_function: Function that determines speaking order
-            speaker_state: Optional state for the speaker function
-        """
-        self.speaker_function = speaker_function
-        if speaker_state:
-            self.speaker_state.update(speaker_state)
-        self._validate_speaker_function()
-        logger.info(
-            f"Speaker function updated to: {speaker_function.__name__}"
-        )
-
-    def set_priorities(self, priorities: dict) -> None:
-        """
-        Set agent priorities for priority-based speaking order.
-
-        Args:
-            priorities: Dictionary mapping agent names to priority weights
-        """
-        self.speaker_state["priorities"] = priorities
-        logger.info(f"Agent priorities set: {priorities}")
-
-    def start_interactive_session(self):
-        """
-        Start an interactive terminal session for chatting with agents.
-
-        This method creates a REPL (Read-Eval-Print Loop) that allows users to:
-        - Chat with agents using @mentions
-        - See available agents and their descriptions
-        - Exit the session using 'exit' or 'quit'
-        - Get help using 'help' or '?'
-        """
-        if not self.interactive:
-            raise InteractiveGroupChatError(
-                "Interactive mode is not enabled. Initialize with interactive=True"
-            )
-
-        print(f"\nWelcome to {self.name}!")
-        print(f"Description: {self.description}")
-        print("\nAvailable agents:")
-        for name, agent in self.agent_map.items():
-            if isinstance(agent, Agent):
-                print(
-                    f"- @{name}: {agent.system_prompt.splitlines()[0]}"
-                )
-            else:
-                print(f"- @{name}: Custom callable function")
-
-        print("\nCommands:")
-        print("- Type 'help' or '?' for help")
-        print("- Type 'exit' or 'quit' to end the session")
-        print("- Use @agent_name to mention agents")
-        print("\nStart chatting:")
-
-        while True:
-            try:
-                # Get user input
-                user_input = input("\nYou: ").strip()
-
-                # Handle special commands
-                if user_input.lower() in ["exit", "quit"]:
-                    print("Goodbye!")
-                    break
-
-                if user_input.lower() in ["help", "?"]:
-                    print("\nHelp:")
-                    print("1. Mention agents using @agent_name")
-                    print(
-                        "2. You can mention multiple agents in one task"
-                    )
-                    print("3. Available agents:")
-                    for name in self.agent_map:
-                        print(f"   - @{name}")
-                    print(
-                        "4. Type 'exit' or 'quit' to end the session"
-                    )
-                    continue
-
-                if not user_input:
-                    continue
-
-                # Process the task and get responses
-                try:
-                    self.run(user_input)
-                    print("\nChat:")
-                    # print(response)
-
-                except NoMentionedAgentsError:
-                    print(
-                        "\nError: Please mention at least one agent using @agent_name"
-                    )
-                except AgentNotFoundError as e:
-                    print(f"\nError: {str(e)}")
-                except Exception as e:
-                    print(f"\nAn error occurred: {str(e)}")
-
-            except KeyboardInterrupt:
-                print("\nSession terminated by user. Goodbye!")
-                break
-            except Exception as e:
-                print(f"\nAn unexpected error occurred: {str(e)}")
-                print(
-                    "The session will continue. You can type 'exit' to end it."
-                )
-
-    def run(self, task: str) -> str:
+        task: str,
+        img: Optional[str] = None,
+        imgs: Optional[List[str]] = None,
+    ) -> str:
         """
         Process a task and get responses from mentioned agents.
         If interactive mode is enabled, this will be called by start_interactive_session().
@@ -591,31 +833,171 @@ Remember: You are part of a team. Your response should reflect that you've read,
             # Add user task to conversation
             self.conversation.add(role="User", content=task)
 
-            # Determine speaking order using speaker function
-            speaking_order = self._get_speaking_order(
-                mentioned_agents
-            )
-            logger.info(
-                f"Speaking order determined: {speaking_order}"
-            )
+            # Handle dynamic speaker function differently
+            if self.speaker_function == random_dynamic_speaker:
+                # Get strategy from speaker state (default to sequential)
+                strategy = self.speaker_state.get(
+                    "strategy", "sequential"
+                )
 
-            # Get responses from mentioned agents in the determined order
-            for agent_name in speaking_order:
-                agent = self.agent_map.get(agent_name)
-                if not agent:
-                    raise AgentNotFoundError(
-                        f"Agent '{agent_name}' not found"
+                # For dynamic speaker, we'll determine the next speaker after each response
+                # Track which agents have spoken to ensure all get a chance
+                spoken_agents = set()
+                last_response = ""
+                max_iterations = (
+                    len(mentioned_agents) * 3
+                )  # Allow more iterations for parallel
+                iteration = 0
+
+                while iteration < max_iterations and len(
+                    spoken_agents
+                ) < len(mentioned_agents):
+                    # Determine next speaker(s) using dynamic function
+                    next_speakers = self.speaker_function(
+                        mentioned_agents,  # Use all mentioned agents, not remaining_agents
+                        last_response,
+                        strategy=strategy,
+                        **self.speaker_state,
                     )
 
-                try:
-                    # Get the complete conversation history
-                    context = (
-                        self.conversation.return_history_as_string()
+                    # Handle both single agent and multiple agents
+                    if isinstance(next_speakers, str):
+                        next_speakers = [next_speakers]
+
+                    # Filter out invalid agents
+                    valid_next_speakers = [
+                        agent
+                        for agent in next_speakers
+                        if agent in mentioned_agents
+                    ]
+
+                    if not valid_next_speakers:
+                        # If no valid mentions found, randomly select from unspoken agents
+                        unspoken_agents = [
+                            agent
+                            for agent in mentioned_agents
+                            if agent not in spoken_agents
+                        ]
+                        if unspoken_agents:
+                            valid_next_speakers = [
+                                random.choice(unspoken_agents)
+                            ]
+                        else:
+                            # All agents have spoken, break the loop
+                            break
+
+                    # Process agents based on strategy
+                    if strategy == "sequential":
+                        # Process one agent at a time
+                        for next_speaker in valid_next_speakers:
+                            if next_speaker in spoken_agents:
+                                continue  # Skip if already spoken
+
+                            response = self._get_agent_response(
+                                next_speaker, img, imgs
+                            )
+                            if response:
+                                last_response = response
+                                spoken_agents.add(next_speaker)
+                                break  # Only process one agent in sequential mode
+
+                    elif strategy == "parallel":
+                        # Process all mentioned agents in parallel
+                        import concurrent.futures
+
+                        # Get responses from all valid agents
+                        responses = []
+                        with concurrent.futures.ThreadPoolExecutor() as executor:
+                            future_to_agent = {
+                                executor.submit(
+                                    self._get_agent_response,
+                                    agent,
+                                    img,
+                                    imgs,
+                                ): agent
+                                for agent in valid_next_speakers
+                                if agent not in spoken_agents
+                            }
+
+                            for (
+                                future
+                            ) in concurrent.futures.as_completed(
+                                future_to_agent
+                            ):
+                                agent = future_to_agent[future]
+                                try:
+                                    response = future.result()
+                                    if response:
+                                        responses.append(response)
+                                        spoken_agents.add(agent)
+                                except Exception as e:
+                                    logger.error(
+                                        f"Error getting response from {agent}: {e}"
+                                    )
+
+                        # Combine responses for next iteration
+                        if responses:
+                            last_response = "\n\n".join(responses)
+
+                    iteration += 1
+            else:
+                # For non-dynamic speaker functions, use the original logic
+                speaking_order = self._get_speaking_order(
+                    mentioned_agents
+                )
+                logger.info(
+                    f"Speaking order determined: {speaking_order}"
+                )
+
+                # Get responses from mentioned agents in the determined order
+                for agent_name in speaking_order:
+                    response = self._get_agent_response(
+                        agent_name, img, imgs
                     )
 
-                    # Get response from agent
-                    if isinstance(agent, Agent):
-                        collaborative_task = f"""{context}
+            return history_output_formatter(
+                self.conversation, self.output_type
+            )
+
+        except InteractiveGroupChatError as e:
+            logger.error(f"GroupChat error: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error: {e}")
+            raise InteractiveGroupChatError(
+                f"Unexpected error occurred: {str(e)}"
+            )
+
+    def _get_agent_response(
+        self,
+        agent_name: str,
+        img: Optional[str] = None,
+        imgs: Optional[List[str]] = None,
+    ) -> Optional[str]:
+        """
+        Get response from a specific agent.
+
+        Args:
+            agent_name: Name of the agent to get response from
+            img: Optional image for the task
+            imgs: Optional list of images for the task
+
+        Returns:
+            The agent's response or None if error
+        """
+        agent = self.agent_map.get(agent_name)
+        if not agent:
+            raise AgentNotFoundError(
+                f"Agent '{agent_name}' not found"
+            )
+
+        try:
+            # Get the complete conversation history
+            context = self.conversation.return_history_as_string()
+
+            # Get response from agent
+            if isinstance(agent, Agent):
+                collaborative_task = f"""{context}
 
 COLLABORATIVE TASK: Please respond to the latest task as {agent_name}.
 
@@ -626,38 +1008,56 @@ IMPORTANT INSTRUCTIONS:
 4. If you need input from other agents, mention them using @agent_name
 5. Provide your unique expertise while showing you understand the group's collective knowledge
 
-Remember: You are part of a collaborative team. Your response should demonstrate that you've read, understood, and are building upon the contributions of others."""
+TASK COMPLETION GUIDELINES:
+- Acknowledge when you are done with your part of the task
+- Clearly state what still needs to be done before the overall task is finished
+- If you mention other agents, explain what specific input you need from them
+- Use phrases like "I have completed [specific part]" or "The task still requires [specific actions]"
 
-                        response = agent.run(task=collaborative_task)
-                    else:
-                        # For callable functions
-                        response = agent(context)
+Remember: You are part of a collaborative team. Your response should demonstrate that you've read, understood, and are building upon the contributions of others."""
 
-                    # Add response to conversation
-                    if response and not response.isspace():
-                        self.conversation.add(
-                            role=agent_name, content=response
-                        )
-                        logger.info(f"Agent {agent_name} responded")
+                response = agent.run(
+                    task=collaborative_task,
+                    img=img,
+                    imgs=imgs,
+                )
+            else:
+                # For callable functions
+                response = agent(context)
 
-                except Exception as e:
-                    logger.error(
-                        f"Error getting response from {agent_name}: {e}"
-                    )
-                    self.conversation.add(
-                        role=agent_name,
-                        content=f"Error: Unable to generate response - {str(e)}",
-                    )
+            # Add response to conversation
+            if response and not response.isspace():
+                self.conversation.add(
+                    role=agent_name, content=response
+                )
+                logger.info(f"Agent {agent_name} responded")
+                return response
 
-            return history_output_formatter(
-                self.conversation, self.output_type
+        except Exception as e:
+            logger.error(
+                f"Error getting response from {agent_name}: {e}"
             )
+            self.conversation.add(
+                role=agent_name,
+                content=f"Error: Unable to generate response - {str(e)}",
+            )
+            return f"Error: Unable to generate response - {str(e)}"
 
-        except InteractiveGroupChatError as e:
-            logger.error(f"GroupChat error: {e}")
-            raise
-        except Exception as e:
-            logger.error(f"Unexpected error: {e}")
-            raise InteractiveGroupChatError(
-                f"Unexpected error occurred: {str(e)}"
+        return None
+
+    def set_dynamic_strategy(self, strategy: str) -> None:
+        """
+        Set the strategy for the random-dynamic-speaker function.
+
+        Args:
+            strategy: Either "sequential" or "parallel"
+                - "sequential": Process one agent at a time based on @mentions
+                - "parallel": Process all mentioned agents simultaneously
+        """
+        if strategy not in ["sequential", "parallel"]:
+            raise ValueError(
+                "Strategy must be either 'sequential' or 'parallel'"
             )
+
+        self.speaker_state["strategy"] = strategy
+        logger.info(f"Dynamic speaker strategy set to: {strategy}")