Upload 7 files

examples/debate/agent/__init__.py

@@ -0,0 +1,2 @@
+# coding: utf-8
+# Copyright (c) 2025 inclusionAI.

examples/debate/agent/base.py

@@ -0,0 +1,45 @@
+from pydantic import BaseModel, Field
+
+from aworld.output import Output
+import asyncio
+
+from aworld.output.base import OutputPart
+
+
+class DebateSpeech(Output, BaseModel):
+    name: str = Field(default="", description="name of the speaker")
+    type: str = Field(default="", description="speech type")
+    stance: str = Field(default="", description="stance of the speech")
+    content: str = Field(default="", description="content of the speech")
+    round: int = Field(default=0, description="round of the speech")
+    finished: bool = Field(default=False, description="round of the speech")
+    metadata: dict = Field(default_factory=dict, description="metadata of the speech")
+
+    async def wait_until_finished(self):
+        """
+        Wait until the speech is finished.
+        """
+        while not self.finished:
+            await asyncio.sleep(1)
+
+    async def convert_to_parts(self, message_output, after_call):
+        async def __convert_to_parts__():
+            async for item in message_output.response_generator:
+                if item:
+                    self.content += item
+                    yield OutputPart(content=item)
+            if message_output.finished:
+                await after_call(message_output.response)
+
+        self.parts = __convert_to_parts__()
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "DebateSpeech":
+        return cls(
+            name=data.get("name", ""),
+            type=data.get("type", ""),
+            stance=data.get("stance", ""),
+            content=data.get("content", ""),
+            round=data.get("round", 0),
+            metadata=data.get("metadata", {})
+        )

examples/debate/agent/debate_agent.py

@@ -0,0 +1,218 @@
+import logging
+from abc import ABC
+from typing import Dict, Any, Union, List, Literal, Optional
+from datetime import datetime
+import uuid
+
+from aworld.models.model_response import ToolCall
+from examples.debate.agent.base import DebateSpeech
+from examples.debate.agent.prompts import user_assignment_prompt, user_assignment_system_prompt, affirmative_few_shots, \
+    negative_few_shots, \
+    user_debate_prompt
+from examples.debate.agent.search.search_engine import SearchEngine
+from examples.debate.agent.search.tavily_search_engine import TavilySearchEngine
+from examples.debate.agent.stream_output_agent import StreamOutputAgent
+from aworld.config import AgentConfig
+from aworld.core.common import Observation, ActionModel
+from aworld.output import SearchOutput, SearchItem, MessageOutput
+from aworld.output.artifact import ArtifactType
+
+
+def truncate_content(raw_content, char_limit):
+    if raw_content is None:
+        raw_content = ''
+    if len(raw_content) > char_limit:
+        raw_content = raw_content[:char_limit] + "... [truncated]"
+    return raw_content
+
+class DebateAgent(StreamOutputAgent, ABC):
+
+    stance: Literal["affirmative", "negative"]
+
+    def __init__(self, name: str, stance: Literal["affirmative", "negative"], conf: AgentConfig, search_engine: Optional[SearchEngine] = TavilySearchEngine()):
+        conf.name = name
+        super().__init__(conf)
+        self.steps = 0
+        self.stance = stance
+        self.search_engine = search_engine
+
+    async def speech(self, topic: str, opinion: str,oppose_opinion: str, round: int, speech_history: list[DebateSpeech]) -> DebateSpeech:
+        observation = Observation(content=self.get_latest_speech(speech_history).content if self.get_latest_speech(speech_history) else "")
+        info = {
+            "topic": topic,
+            "round": round,
+            "opinion": opinion,
+            "oppose_opinion": oppose_opinion,
+            "history": speech_history
+        }
+        actions = await self.async_policy(observation, info)
+
+        return actions[0].policy_info
+
+
+    async def async_policy(self, observation: Observation, info: Dict[str, Any] = {}, **kwargs) -> Union[
+        List[ActionModel], None]:
+        ## step 1: params
+        opponent_claim = observation.content
+        round = info["round"]
+        opinion = info["opinion"]
+        oppose_opinion = info["oppose_opinion"]
+        topic = info["topic"]
+        history: list[DebateSpeech] = info["history"]
+
+        #Event.emit("xxx")
+        ## step2: gen keywords
+        keywords = await self.gen_keywords(topic, opinion, oppose_opinion, opponent_claim, history)
+        logging.info(f"gen keywords = {keywords}")
+
+        ## step3：search_webpages
+        search_results = await self.search_webpages(keywords, max_results=5)
+        for search_result in search_results:
+            logging.info(f"keyword#{search_result['query']}-> result size is {len(search_result['results'])}")
+            search_item = {
+                "query": search_result.get("query", ""),
+                "results": [SearchItem(title=result["title"],url=result["url"], content=result['content'], raw_content=result['raw_content'], metadata={}) for result in search_result["results"]],
+                "origin_tool_call": ToolCall.from_dict({
+                    "id": f"call_search",
+                    "type": "function",
+                    "function": {
+                        "name": "search",
+                        "arguments": keywords
+                    }
+                })
+            }
+            search_output = SearchOutput.from_dict(search_item)
+            await self.workspace.create_artifact(
+                artifact_type=ArtifactType.WEB_PAGES,
+                artifact_id=str(uuid.uuid4()),
+                content=search_output,
+                metadata={
+                    "query": search_output.query,
+                    "user": self.name(),
+                    "round": info["round"],
+                    "opinion": info["opinion"],
+                    "oppose_opinion": info["oppose_opinion"],
+                    "topic": info["topic"],
+                    "tags": [f"user#{self.name()}",f"Rounds#{info['round']}"]
+                }
+            )
+
+        ## step4 gen result
+        user_response = await self.gen_statement(topic, opinion, oppose_opinion, opponent_claim, history, search_results)
+
+        logging.info(f"user_response is {user_response}")
+
+        ## step3: gen speech
+        speech = DebateSpeech.from_dict({
+            "round": round,
+            "type": "speech",
+            "stance": self.stance,
+            "name": self.name(),
+        })
+
+        async def after_speech_call(message_output_response):
+            logging.info(f"{self.stance}#{self.name()}: after_speech_call")
+            speech.metadata = {}
+            speech.content = message_output_response
+            speech.finished = True
+
+        await speech.convert_to_parts(user_response, after_speech_call)
+
+        action = ActionModel(
+            policy_info=speech
+        )
+
+        return [action]
+
+
+    async def gen_keywords(self, topic, opinion, oppose_opinion, last_oppose_speech_content, history):
+
+        current_time = datetime.now().strftime("%Y-%m-%d-%H")
+        human_prompt = user_assignment_prompt.format(topic=topic,
+                                                     opinion=opinion,
+                                                     oppose_opinion=oppose_opinion,
+                                                     last_oppose_speech_content=last_oppose_speech_content,
+                                                     current_time = current_time,
+                                                     limit=2
+                                                     )
+
+        messages = [{'role': 'system', 'content': user_assignment_system_prompt},
+                    {'role': 'user', 'content': human_prompt}]
+
+        output = await self.async_call_llm(messages)
+
+        response = await output.get_finished_response()
+
+        return response.split(",")
+
+    async def search_webpages(self, keywords, max_results):
+        return await self.search_engine.async_batch_search(queries=keywords, max_results=max_results)
+
+    async def gen_statement(self, topic, opinion, oppose_opinion, opponent_claim, history, search_results) -> MessageOutput:
+        search_results_content = ""
+        for search_result in search_results:
+            search_results_content += f"SearchQuery: {search_result['query']}"
+            search_results_content += "\n\n".join([truncate_content(s['content'], 1000) for s in search_result['results']])
+
+        unique_history = history
+        # if len(history) >= 2:
+        #     for i in range(len(history)):
+        #         # Check if the current element is the same as the next one
+        #         if i == len(history) - 1 or history[i] != history[i+1]:
+        #             # Add the current element to the result list
+        #             unique_history.append(history[i])
+
+
+        affirmative_chat_history = ""
+        negative_chat_history = ""
+
+        if len(unique_history) >= 2:
+            if self.stance == "affirmative":
+                for speech in unique_history[:-1]:
+                    if speech.stance == "affirmative":
+                        affirmative_chat_history = affirmative_chat_history + "You: " + speech.content + "\n"
+                    elif speech.stance == "negative":
+                        affirmative_chat_history = affirmative_chat_history + "Your Opponent: " + speech.content + "\n"
+
+            elif self.stance == "negative":
+                for speech in unique_history[:-1]:
+                    if speech.stance == "negative":
+                        negative_chat_history = negative_chat_history + "You: " + speech.content + "\n"
+                    elif speech.stance == "affirmative":
+                        negative_chat_history = negative_chat_history + "Your Opponent: " + speech.content + "\n"
+
+        few_shots = ""
+        chat_history = ""
+
+        if self.stance == "affirmative":
+            chat_history = affirmative_chat_history
+            few_shots = affirmative_few_shots
+
+        elif self.stance == "negative":
+            chat_history = negative_chat_history
+            few_shots = negative_few_shots
+
+        human_prompt = user_debate_prompt.format(topic=topic,
+                                                opinion=opinion,
+                                                oppose_opinion=oppose_opinion,
+                                                last_oppose_speech_content=opponent_claim,
+                                                search_results_content=search_results_content,
+                                                chat_history = chat_history,
+                                                few_shots = few_shots
+                                                )
+
+        messages = [{'role': 'system', 'content': user_assignment_system_prompt},
+                    {'role': 'user', 'content': human_prompt}]
+
+        return await self.async_call_llm(messages)
+
+    def get_latest_speech(self, history: list[DebateSpeech]):
+        """
+        get the latest speech from history
+        """
+        if len(history) == 0:
+            return None
+        return history[-1]
+
+    def set_workspace(self, workspace):
+        self.workspace = workspace

examples/debate/agent/main.py

@@ -0,0 +1,210 @@
+import logging
+import uuid
+from typing import Optional, AsyncGenerator
+
+from aworld.memory.main import MemoryFactory
+from examples.debate.agent.base import DebateSpeech
+from examples.debate.agent.debate_agent import DebateAgent
+from examples.debate.agent.moderator_agent import ModeratorAgent
+from aworld.core.common import Observation
+from aworld.core.memory import MemoryItem, MemoryConfig
+from aworld.output import Output, WorkSpace, Artifact, ArtifactType, CodeArtifact
+
+
+class DebateArena:
+    """
+    DebateArena is platform for debate
+    """
+
+    affirmative_speaker: DebateAgent
+    negative_speaker: DebateAgent
+
+    moderator: Optional[ModeratorAgent]
+
+    speeches: list[DebateSpeech]
+
+    display_panel: str
+
+    def __init__(self,
+                 affirmative_speaker: DebateAgent,
+                 negative_speaker: DebateAgent,
+                 moderator: ModeratorAgent,
+                 workspace: WorkSpace,
+                 **kwargs
+                 ):
+        self.affirmative_speaker = affirmative_speaker
+        self.negative_speaker = negative_speaker
+        self.moderator = moderator
+        self.speeches = []
+        self.workspace = workspace
+        self.affirmative_speaker.set_workspace(workspace)
+        self.negative_speaker.set_workspace(workspace)
+        self.moderator.set_workspace(workspace)
+        self.moderator.memory = MemoryFactory.from_config(MemoryConfig(provider="inmemory", enable_summary=False))
+
+        # Event.register("topic", func= );
+
+    async def async_run(self, topic: str, rounds: int) \
+            -> AsyncGenerator[Output, None]:
+
+        """
+        Start the debate
+        1. debate will start from round 1
+        2. each round will have two speeches, one from affirmative_speaker and one from negative_speaker
+        3. after all rounds finished, the debate will end
+
+        Args:
+            topic: str -> topic of the debate
+            affirmative_opinion: str -> affirmative speaker's opinion
+            negative_opinion: str -> negative speaker's opinion
+            rounds: int -> number of rounds
+
+        Returns: list[DebateSpeech]
+
+        """
+
+        ## 1. generate opinions
+        moderator_speech = await self.moderator_speech(topic, rounds)
+        if not moderator_speech:
+            return
+        yield moderator_speech
+        await moderator_speech.wait_until_finished()
+        self.store_speech(moderator_speech)
+
+        affirmative_opinion = moderator_speech.metadata["affirmative_opinion"]
+        negative_opinion = moderator_speech.metadata["negative_opinion"]
+
+        logging.info(f"✈️==================================== opinions =============================================")
+        logging.info(f"topic: {topic}")
+        logging.info(f"affirmative_opinion: {affirmative_opinion}")
+        logging.info(f"negative_opinion: {negative_opinion}")
+        logging.info(f"✈️==================================== start... =============================================")
+
+        ## 2. Alternating speeches
+        for i in range(1, rounds + 1):
+            logging.info(
+                f"✈️==================================== round#{i} start =============================================")
+            loading_speech = DebateSpeech.from_dict({
+                "content": f"\n\n**round#{i} start** \n\n",
+                "round": i,
+                "type": "loading",
+                "stance": "stage",
+                "name": "stage",
+                "finished": True
+            })
+            yield loading_speech
+
+            loading_speech = DebateSpeech.from_dict({
+                "content": f"\n\n【affirmative】✅：{self.affirmative_speaker.name()}\n Searching ....\n",
+                "round": i,
+                "type": "loading",
+                "stance": "stage",
+                "name": "stage",
+                "finished": True
+            })
+            yield loading_speech
+
+            # affirmative_speech
+            speech = await self.affirmative_speech(i, topic, affirmative_opinion, negative_opinion)
+            yield speech
+            await speech.wait_until_finished()
+            self.store_speech(speech)
+
+            loading_speech = DebateSpeech.from_dict({
+                "content": f"\n\n【negative】❌：{self.negative_speaker.name()}\n Searching ....\n",
+                "round": i,
+                "type": "loading",
+                "stance": "stage",
+                "name": "stage",
+                "finished": True
+            })
+            yield loading_speech
+
+            # negative_speech
+            speech = await self.negative_speech(i, topic, negative_opinion, affirmative_opinion)
+            yield speech
+            await speech.wait_until_finished()
+            self.store_speech(speech)
+
+            logging.info(
+                f"🛬==================================== round#{i} end =============================================")
+
+        ## 3. Summary speeches
+        moderator_speech = await self.moderator.summary_speech()
+        if not moderator_speech:
+            return
+        yield moderator_speech
+        await moderator_speech.wait_until_finished()
+        await self.workspace.add_artifact(
+            CodeArtifact.build_artifact(
+                artifact_type=ArtifactType.CODE,
+                artifact_id="result",
+                code_type='html',
+                content=moderator_speech.content,
+                metadata={
+                    "topic": topic
+                }
+            )
+        )
+        logging.info(
+            f"🛬====================================  total is end =============================================")
+
+    async def moderator_speech(self, topic, rounds) -> DebateSpeech | None:
+        results = await self.moderator.async_policy(Observation(content=topic, info={"rounds": rounds}))
+        if not results or not results[0] or not results[0].policy_info:
+            return None
+        return results[0].policy_info
+
+    async def affirmative_speech(self, round: int, topic: str, opinion: str, oppose_opinion: str) -> DebateSpeech:
+        """
+        affirmative_speaker will start speech
+        """
+
+        affirmative_speaker = self.get_affirmative_speaker()
+
+        logging.info(affirmative_speaker.name() + ": " + "start")
+
+        speech = await affirmative_speaker.speech(topic, opinion, oppose_opinion, round, self.speeches)
+
+        logging.info(affirmative_speaker.name() + ":  result: " + speech.content)
+        return speech
+
+    async def negative_speech(self, round: int, topic: str, opinion: str, oppose_opinion: str) -> DebateSpeech:
+        """
+        after affirmative_speaker finished speech, negative_speaker will start speech
+        """
+
+        negative_speaker = self.get_negative_speaker()
+
+        logging.info(negative_speaker.name() + ": " + "start")
+
+        speech = await negative_speaker.speech(topic, opinion, oppose_opinion, round, self.speeches)
+
+        logging.info(negative_speaker.name() + ":  result: " + speech.content)
+        return speech
+
+    def get_affirmative_speaker(self) -> DebateAgent:
+        """
+        return the affirmative speaker
+        """
+        return self.affirmative_speaker
+
+    def get_negative_speaker(self) -> DebateAgent:
+        """
+        return the negative speaker
+        """
+        return self.negative_speaker
+
+    def store_speech(self, speech: DebateSpeech):
+        self.moderator.memory.add(MemoryItem.from_dict({
+            "content": speech.content,
+            "metadata": {
+                "round": speech.round,
+                "speaker": speech.name,
+                "type": speech.type
+            }
+        }))
+        self.speeches.append(speech)
+
+    def gen_closing_statement(self):
+        pass

examples/debate/agent/moderator_agent.py

@@ -0,0 +1,146 @@
+import logging
+from abc import ABC
+from datetime import datetime
+from typing import Dict, Any, Union, List
+
+from pydantic import Field
+
+from aworld.config import AgentConfig
+from aworld.core.common import Observation, ActionModel
+from aworld.output import MessageOutput, WorkSpace, ArtifactType, SearchOutput
+from examples.debate.agent.base import DebateSpeech
+from examples.debate.agent.prompts import user_assignment_system_prompt, summary_system_prompt, summary_debate_prompt
+from examples.debate.agent.stream_output_agent import StreamOutputAgent
+
+
+def truncate_content(raw_content, char_limit):
+    if raw_content is None:
+        raw_content = ''
+    if len(raw_content) > char_limit:
+        raw_content = raw_content[:char_limit] + "... [truncated]"
+    return raw_content
+
+
+class ModeratorAgent(StreamOutputAgent, ABC):
+    stance: str = "moderator"
+    topic: str = Field(default=None)
+    affirmative_opinion: str = Field(default=None)
+    negative_opinion: str = Field(default=None)
+
+    def __init__(self, conf: AgentConfig,
+                 **kwargs
+                 ):
+        super().__init__(conf)
+
+
+    async def async_policy(self, observation: Observation, info: Dict[str, Any] = {}, **kwargs) -> Union[
+        List[ActionModel], None]:
+        ## step 1: params
+        topic = observation.content
+
+        ## step2: gen opinions
+        output = await self.gen_opinions(topic)
+
+        ## step3: gen speech
+        moderator_speech = DebateSpeech.from_dict({
+            "content": "",
+            "round": 0,
+            "type": "speech",
+            "stance": "moderator",
+            "name": self.name(),
+        })
+
+        async def after_speech_call(message_output_response):
+            logging.info("moderator: after_speech_call")
+            opinions = message_output_response
+            self.affirmative_opinion = opinions.get("positive_opinion")
+            self.negative_opinion = opinions.get("negative_opinion")
+            moderator_speech.metadata = {
+                "topic": topic,
+                "affirmative_opinion": self.affirmative_opinion,
+                "negative_opinion": self.negative_opinion,
+            }
+            moderator_speech.finished = True
+
+        await moderator_speech.convert_to_parts(output, after_speech_call)
+
+        action = ActionModel(
+            policy_info=moderator_speech
+        )
+
+        return [action]
+
+    async def gen_opinions(self, topic) -> MessageOutput:
+
+        current_time = datetime.now().strftime("%Y-%m-%d-%H")
+        human_prompt = self.agent_prompt.format(topic=topic,
+                                                current_time=current_time,
+                                                )
+
+        messages = [
+            {"role": "system", "content": user_assignment_system_prompt},
+            {"role": "user", "content": human_prompt}
+        ]
+
+        output = await self.async_call_llm(messages, json_parse=True)
+
+        return output
+
+    async def summary_speech(self) -> DebateSpeech:
+
+        chat_history = await self.get_formated_history()
+        print(f"chat_history is \n {chat_history}")
+
+        search_results_content_history = await self.get_formated_search_results_content_history()
+        print(f"search_results_content_history is \n {search_results_content_history}")
+
+        human_prompt = summary_debate_prompt.format(topic=self.topic,
+                                                    opinion=self.affirmative_opinion,
+                                                    oppose_opinion=self.negative_opinion,
+                                                    chat_history=chat_history,
+                                                    search_results_content_history=search_results_content_history
+                                                    )
+
+        messages = [
+            {"role": "system", "content": summary_system_prompt},
+            {"role": "user", "content": human_prompt}
+        ]
+
+        output = await self.async_call_llm(messages, json_parse=False)
+
+        moderator_speech = DebateSpeech.from_dict({
+            "content": "",
+            "round": 0,
+            "type": "summary",
+            "stance": "moderator",
+            "name": self.name(),
+        })
+
+        async def after_speech_call(message_output_response):
+            moderator_speech.finished = True
+
+        await moderator_speech.convert_to_parts(output, after_speech_call)
+
+        return moderator_speech
+
+    async def get_formated_history(self):
+        formated = []
+        for item in self.memory.get_all():
+            formated.append(f"{item.metadata['speaker']} (round {item.metadata['round']}): {item.content}")
+        return "\n".join(formated)
+
+    async def get_formated_search_results_content_history(self):
+        if not self.workspace:
+            return
+        search_results = self.workspace.list_artifacts(ArtifactType.WEB_PAGES)
+        materials = []
+        for search_result in search_results:
+            if isinstance(search_result.content, SearchOutput):
+                for item in search_result.content.results:
+                    materials.append(
+                        f"{search_result.metadata['user']} (round {search_result.metadata['round']}): {search_result.content.query}: url: {item.url}, title: {item.title}, description: {item.content}")
+
+        return "\n".join(materials)
+
+    def set_workspace(self, workspace: WorkSpace):
+        self.workspace = workspace

examples/debate/agent/prompts.py

@@ -0,0 +1,251 @@
+user_assignment_system_prompt = "You are a helpful search agent."
+
+user_assignment_prompt = """
+While facing the hot topic: {topic}, your opinion is {opinion}. You stand on your opinion and fight any other opinion (such as {oppose_opinion}) that differs from your opinion.
+
+You have an assistant that can help search the relative materials online to support your opinion {opinion} in the topic: {topic}
+
+While facing your opponent's claim {last_oppose_speech_content}, you decide to fight back! Now you need to ask your assistant to do some online survey, according to that claim, to give you more insights to decide what to debate with your opponent.
+
+For example, you could talk to your assistant to search: A, B, C . Then you will gain more insights and can decide how to fight back!
+
+Attention: You need to pay attention the current time ({current_time}). 
+If you want to search something that is sensitive to the time, espcially some materials are needed to be up to date, you need to output your assignment queries associated with the current time, so your assistant can search the up to date search.
+
+
+Format Requirements (query seperated by , ), limit {limit}:
+aaa, bbb, ccc...
+
+Now, you could output your assignment queries (strictly follow the Format Requirements: seperated by ,) to your assistant.
+"""
+
+user_debate_system_prompt = "You are an impressive debater."
+user_debate_prompt = """
+## Role
+You are an outstanding debater, with a fiery and stubborn personality, sharp language, and a penchant for irony. 
+Your responsibility is to respond to the content of the opposing debater's speech based on the current debate topic, your stance, your skills, and restrictions.
+
+
+## Current Debate Topic
+{topic}
+
+## Your Stance
+{opinion}
+
+## Opponent's Stance
+{oppose_opinion}
+
+
+## Your Skills
+- You have a strong sense of self-esteem, a bit rebellious, enjoy arguing back, and speak quite aggressively.
+- Sometimes you like to use habitual rhetorical questions to belittle the opponent.
+- When you sense the opponent is about to leave or the conversation is hard to continue due to lack of topics, you can throw out provocative questions related to the current debate topic to challenge the opponent.
+- You excel at finding loopholes in the opponent's arguments and incessantly attacking their weaknesses.
+- You are adept at using reference materials to support your arguments with facts and counter the opponent's loopholes.
+- Your language is concise and incisive, always able to capture the key points. When responding, you can settle the matter in just three or four sentences without the need for lengthy explanations.
+
+
+## Attention
+- It is strictly prohibited to use phrases like “let’s switch to a lighter topic.”
+- The output content must be organized according to the given format and must not deviate from the framework requirements.
+- If you recoginize that there is no history chat and your opponent has not said anything yet, it means you are on the first round, you need to directly and briefly state your opinion to your opponent.
+- You are not allowed to output your inner thinking chain, just directly speak out to your opponent.
+- Please do not say too much, it will make you seem too mild, which directly undermines your character. 
+- Be brief and sharp, and use sarcasm frequently. Limit your response within 100-150 words.
+- DO NOT output your response starting with 'You:', JUST DIRECTLY output your response without "You:".
+
+
+## Dialogue Style Examples
+{few_shots}
+
+
+## Current Task
+You are arguing with your opponent on the topic: {topic}. You opinion is {opinion}.
+Below is the content of your conversation:
+{chat_history}
+
+Now, your opponent just said to you: “{last_oppose_speech_content}”.
+
+At this moment, you have obtained the following related materials, which may be beneficial for your rebuttal against the opponent.
+
+Reference materials: {search_results_content}
+
+
+Please use your character's identity traits, skills, restrictions, and dialogue style examples, relying on your reference materials, to counter the opposing debater in a incisive and concise way. Never output "You:". Now, please directly output your response to your opponent without "You:".
+"""
+
+affirmative_few_shots = """
+Your opponent:
+You: Let me make it straight, Jordan is the best, who dares to oppose?
+
+Your opponent: James has a better character. Even when JR Smith made a blunder in the finals, LeBron was still supportive. If it were Jordan, he would have chased him around the court in anger.
+You: Cut it out! Michael Jordan was a ruthless winner on the court. He wouldn't tolerate any mistakes, and it's this relentless standard that earned him six championships and never failing in the finals. So, no matter how much of a nice guy LeBron tries to be, it won't erase his multiple finals defeats.
+
+Your opponent: James has a stronger body, and physique is the most important factor on basketball court.
+You: My Jesus, I can't believe someone would say that. Bastetball is far beyond physique. Skills, mind and leadership all matters. In these aspects, James is no match for Jordan. If James is so proud of his physique, why doesn't he go work in the fields?
+"""
+
+negative_few_shots = """
+Your opponent:
+You: Let me make it straight, Lebron is the best, who dares to oppose?
+
+Your opponent: With no doubt, Jordan's skills are more well-rounded.
+You: Would you stop kidding...Since Jordan's skills are supposedly so well-rounded, then tell me why his three-point shooting percentage is so low. Jordan was just given a greater personal boost because of the unique era he played in.
+"""
+
+generate_opinions_prompt = """
+Here is the debate topic:{topic}.
+Please output the two sides' (positive side vs negative side) opinions of the topic.
+
+Output format:
+{{
+   "positive_opinion":"xxx"
+   "negative_opinion":"yyy"
+}}
+
+
+Now the topic is {topic}, please follow the example and output format, output the two sides' opinions.
+you must always return json, don not return markdown tag or others ，such as ```json,``` etc;
+
+
+For example:
+----------------------------------
+topic: Who is better? A or B?
+
+{{
+   "positive_opinion":"A"
+   "negative_opinion":"B"
+}}
+
+----------------------------------
+topic: Is is OK to drink wine?
+positive_opinion:Yes
+negative_opinion:No
+
+{{
+   "positive_opinion":"Yes"
+   "negative_opinion":"No"
+}}
+"""
+
+summary_system_prompt = "You are a good assistant to make summary."
+summary_debate_prompt = """
+## Your Role
+You are a reliable assistant to make summary and skilled in information architecture and visual storytelling, capable of transforming any content into stunning cards using a webpage format. 
+Your responsibility is: 1. read people's conversation and make summary on this conversation; 2. translate your summary into the HTML code. 
+
+
+## Current Situation
+1. You find that several people have started a debate on a particular topic "{topic}";
+2. One side is holding the opinion: {opinion}, the other side is holding: {oppose_opinion}. 
+   2.1 For the details of the conversation between these two sides, please refer to Conversation History below.
+3. Each time one side is giving the conversation, he/she would like to cite the supportive materials searched on the website, in form of the urls, title, descritpion. 
+   3.1 For the details of the supportive materials between these two sides for each conversation round, please refer to Supportive Materials History below.
+4. Now you are supposed to make a concise, brief summary for each round conversation between the two sides, in terms of the viewpoint, citation.
+   4.1 'viewpoint' is the main point for each side in each conversation round;
+   4.2 'citation' is the formatted structure in terms of the urls, title of the supportive materials that is indeed cited in each conversation round.
+
+
+## Conversation History:
+{chat_history}
+
+
+## Supportive Materials History
+{search_results_content_history}
+
+
+## Summary Format
+debater_name1's summary (round 1): xxxx
+debater_name1's citation(round 1): url_1: xxxx, title_1: xxxx; url_2: xxxx, title_2: xxxx
+
+debater_name2's summary (round 1): yyyy
+debater_name2's citation(round 1): url_1: yyyy, title_1: yyyy; url_2: yyyy, title_2: yyyy...
+
+debater_name1's summary (round 2): pppp
+debater_name1's citation(round 2): url_1: pppp, title_1: pppp; url_2: pppp, title_2: pppp
+
+debater_name2's summary (round 2): qqqq
+debater_name2's citation(round 2): url_1: qqqq, title_1: qqqq; url_2: qqqq, title_2: qqqq...
+...
+
+
+## Write HTML Requirements
+1. You should only present using HTML code, including basic HTML, CSS, and JavaScript. This should encompass text, visualization, and structured results.
+2. Provide complete HTML code; CSS and JavaScript should also be included within the code to ensure the user can open a single file.
+3. Do not arbitrarily omit the core viewpoints from the original text; core viewpoints and summaries must be preserved.
+
+
+## Write HTML Technical Implementation
+1. Utilize modern CSS techniques (such as flex/grid layouts, variables, gradients)
+2. Ensure the code is clean and efficient, without redundant elements
+3. Add a save button that does not interfere with the design
+4. Implement a one-click save as image feature using html2canvas
+5. The saved image should only contain the cover design, excluding interface elements
+6. Use Google Fonts or other CDNs to load appropriate modern fonts
+7. Online icon resources can be used (such as Font Awesome)
+
+
+## Write HTML Professional Typography Techniques
+1. Apply the designer's common "negative space" technique to create focal points
+2. Maintain harmonious proportion between text and decorative elements
+3. Ensure a clear visual flow to guide the reader’s eye movement
+4. Use subtle shadow or light effects to increase depth
+5. For webpage URL addresses and their corresponding titles, use hyperlinks.
+
+
+## Example
+Topic: Which is more important to success? Working hard or Opportunity?
+
+Conversation History:
+Tom (round 1): Hard work can help individuals continuously improve their skills and professional knowledge, laying a solid foundation for achieving success. A programmer Kim spends time every day learning new languages and technologies, eventually becoming an expert in the field and securing an important position at a major tech company.
+Jerry (round 1): Opportunity is more important. Steve Jobs saw the great potential of personal computer, then he found Apple. 
+Tom (round 2): Many famous entrepreneurs experienced numerous setbacks and failures before achieving success. They did not just happen to be lucky enough to get opportunities, but rather, through continuous effort and relentless perseverance, they eventually succeeded. For example, Thomas Edison conducted thousands of experiments in the process of inventing the light bulb, which demonstrates that his success was inseparable from his tenacious effort.
+Jerry (round 2): Many historical events were driven by opportunities rather than purely by abilities. For example, during wars, some generals won battles because they made crucial decisions at key moments, even though they were not the most experienced commanders.
+
+Supportive Materials History:
+Tom (round 1): id1: url: aaaa, title: Why is Kim? description: bbbb.
+Jerry (round 1): id1: url: cccc, title: Steve's story. description: dddd.
+Tom (round 2): id1: url: eeee, title: The invention of light bulb. description: ffff.
+Jerry (round 2): id1: url: gggg, title: Some interesting things during the war. description: hhhh.
+
+Your Summary:
+Tom's summary (round 1): Hard working improves people's skills and thus leads to personal sucess. 
+Tom's citation (round 1): url_1: aaaa, title_1: Why is Kim?
+
+Jerry's summary (round 1): Steve's story supports opportunity is more important. 
+Jerry's citation (round 1): url_1:cccc, title_1:Steve's story.
+
+Tom's summary (round 2): Entrepreneurs, like Thomas Edison, faced repeated failures before succeeding. Their achievements resulted from persistent effort and perseverance, not mere luck.
+Tom's citation (round 2): url_1: eeee, title_1: The invention of light bulb.
+
+Jerry's summary (round 2): Historical events are often driven by opportunity, as seen when generals win battles through timely decisions rather than experience.
+Jerry's citation (round 2): url_1:gggg, title_1: Some interesting things during the war.
+
+
+
+## Attention
+- Strictly follow the ## Output Format. The output content must be organized according to the ## Output Format and must not deviate from the framework requirements.
+- The summary of each side's each conversation round should be very concise (it would be better within 30 words), cannot be too long. Just capture the key points.
+- Only the supportive materials that has been indeed referred by the debater can appear in the citation, in terms of their urls and the titles. Ignore the materials that have not been referred by the debater.
+- You are not allowed to output your inner thinking chain.
+- DO NOT output your response starting with 'You:', JUST DIRECTLY output your response without "You:".
+- Please output your summary in the HTML form directly in one step.
+
+
+
+Please deeply understand Your Role and Current Situation. Strictly follow the Summary Format, Attention with Example, output your summary, according to the Conversation History and Supportive Materials History. 
+Then transfer your summary according to the Write HTML Requirements, Write HTML Technical Implementation, Write HTML Professional Typography Techniques.
+"""
+
+# ## Conversation History:
+# Jake (round1): Jordan is the best, he scores 35.1 points per game. No one is better than that.
+# Lucy (round1): Jordan's opponent is too weak, Lebron's opponent is stronger, so James is better.
+# Jake (round2): Jordan is the best, he has 6 champions. No one is better than that.
+# Lucy (round2): Jordan's teamates are better, pippen, rodman... Lebron leads the whole team forward.
+
+
+# ## Supportive Materials History
+# Jake (round1): url_1: 123, title_1: Jordan's data; 
+# Lucy (round1): url_1: 456, title_1: The diff between basketball's eras; url_2: 9999, title_2: which second-order wave forces on hydrodynamcis. 
+# Jake (round2): url_1: 123678aa, title_1: Who's got most champions? 
+# Lucy (round2): url_1: xxxbbbw45, title_1: The importance of teammates.

examples/debate/agent/stream_output_agent.py

@@ -0,0 +1,19 @@
+from aworld.config import AgentConfig
+from aworld.agents.llm_agent import Agent
+from aworld.models.llm import acall_llm_model_stream
+from aworld.output import MessageOutput
+
+
+class StreamOutputAgent(Agent):
+    def __init__(self, conf: AgentConfig, **kwargs
+                 ):
+        super().__init__(conf)
+
+    async def async_call_llm(self, messages, json_parse=False) -> MessageOutput:
+        # Async streaming with acall_llm_model
+        async def async_generator():
+            async for chunk in acall_llm_model_stream(self.llm, messages, stream=True):
+                if chunk.content:
+                    yield chunk.content
+
+        return MessageOutput(source=async_generator(), json_parse=json_parse)