realtimex-agent-a2a-agent 0.2.0__tar.gz

realtimex_agent_a2a_agent-0.2.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.3
+Name: realtimex-agent-a2a-agent
+Version: 0.2.0
+Summary: Add your description here
+Author: rta_phuongnguyen
+Author-email: rta_phuongnguyen <phuongnguyen@rtanalytics.vn>
+Requires-Dist: realtimex-any-agent
+Requires-Dist: ollama
+Requires-Dist: google-genai
+Requires-Dist: realtimex-any-agent[a2a]
+Requires-Dist: realtimex-any-agent[langchain]
+Requires-Dist: realtimex-any-agent[deepagents]
+Requires-Dist: nest-asyncio
+Requires-Dist: openai
+Requires-Dist: aci-mcp==1.0.0b13
+Requires-Dist: mem0ai==0.1.116
+Requires-Dist: redis
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+

realtimex_agent_a2a_agent-0.2.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "realtimex-agent-a2a-agent"
+version = "0.2.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "rta_phuongnguyen", email = "phuongnguyen@rtanalytics.vn" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "realtimex-any-agent",
+    "ollama",
+    "google-genai",
+    "realtimex-any_agent[a2a]",
+    "realtimex-any-agent[langchain]",
+    "realtimex-any_agent[deepagents]",
+    "nest_asyncio",
+    "openai",
+    "aci-mcp==1.0.0b13",
+    "mem0ai==v0.1.116",
+    "redis",
+]
+
+# [tool.uv.sources]
+# any_agent = { git = "https://github.com/therealtimex/any-agent", branch = "realtimex" }
+# any_agent = { path = "/Users/phuongnguyen/Documents/projects/any-agent" }
+
+[project.scripts]
+realtimex-agent-a2a-agent = "realtimex_agent_a2a_agent.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.8.2,<0.9.0"]
+build-backend = "uv_build"

realtimex_agent_a2a_agent-0.2.0/src/realtimex_agent_a2a_agent/__init__.py

@@ -0,0 +1,5 @@
+from .agent import RealTimeXAgent
+
+__all__ = [
+    "RealTimeXAgent"
+]

realtimex_agent_a2a_agent-0.2.0/src/realtimex_agent_a2a_agent/agent.py

@@ -0,0 +1,721 @@
+from any_agent import AgentConfig, AnyAgent
+from any_agent.config import MCPStdio
+import json
+import os
+from typing import Callable, Dict, Literal, Optional, Union, Any
+
+from .tools import send_email
+from .callbacks.tool_execution import ShowToolCalling
+from any_agent.callbacks import get_default_callbacks
+from mem0 import Memory
+from any_agent.tools import a2a_tool_async
+from any_agent.serving import A2AServingConfig
+
+
+def get_user_dir():
+    return os.path.join(os.path.expanduser("~"),".realtimex.ai")
+
+def get_base_user_dir():
+    return os.path.join(os.path.expanduser("~"))
+
+def get_uvx_executable():
+    unix_realtimex_uvx_path = os.path.join(get_user_dir(),"Resources","envs","bin","uvx")
+    if os.path.exists(unix_realtimex_uvx_path):
+        return unix_realtimex_uvx_path
+    win_realtimex_uvx_path = os.path.join(get_user_dir(),"Resources","envs","Scripts","uvx.exe")
+    if os.path.exists(win_realtimex_uvx_path):
+        return win_realtimex_uvx_path
+    return "uvx"
+
+def get_nvm_dir():
+    path = os.path.join(get_base_user_dir(),".nvm")
+    if os.path.exists(path):
+        return path
+    path = os.path.join('c:', os.sep, "nvm")
+    if os.path.exists(path):
+        return path
+    return ""
+
+
+def get_nvm_inc():
+    # /Users/phuongnguyen/.nvm/versions/node/v22.16.0/include/node
+    path = os.path.join(get_nvm_dir(),"versions","node","v22.16.0","include","node")
+    if os.path.exists(path):
+        return path
+    path = os.path.join('c:', os.sep, "nvm")
+    if os.path.exists(path):
+        return path
+    return ""
+
+def get_nvm_bin():
+    # /Users/phuongnguyen/.nvm/versions/node/v22.16.0/include/node
+    path = os.path.join(get_nvm_dir(),"versions","node","v22.16.0","bin")
+    if os.path.exists(path):
+        return path
+    path = os.path.join('c:', os.sep, "nvm")
+    if os.path.exists(path):
+        return path
+    return ""
+
+def get_npx_executable():
+    unix_realtimex_npx_path = os.path.join(get_base_user_dir(),".nvm","versions","node","v22.16.0","bin","npx")
+    if os.path.exists(unix_realtimex_npx_path):
+        return unix_realtimex_npx_path
+    win_realtimex_npx_path = os.path.join('c:', os.sep, "nvm", "v22.16.0", "npx.cmd")
+    if os.path.exists(win_realtimex_npx_path):
+        return win_realtimex_npx_path
+    return "npx"
+
+
+def get_deepagents_agent_path(scope, agent_id, workspace_slug=None):
+    """
+    Get the agent.md path for DeepAgents.
+    
+    Args:
+        scope: 'global' or 'workspace'
+        agent_id: The agent identifier
+        workspace_slug: Required when scope is 'workspace'
+    
+    Returns:
+        Path string if file exists, None otherwise
+    """
+    if scope == "global":
+        path = os.path.join(
+            get_user_dir(), "Resources", "agent-skills", "global", agent_id, "agent.md"
+        )
+    elif scope == "workspace" and workspace_slug:
+        path = os.path.join(
+            get_user_dir(), "Resources", "agent-skills", "workspaces", workspace_slug, agent_id, "agent.md"
+        )
+    else:
+        return None
+    
+    return path if os.path.isfile(path) else None
+
+
+def get_deepagents_skills_dir(scope, agent_id, workspace_slug=None):
+    """
+    Get the skills directory path for DeepAgents.
+    
+    Args:
+        scope: 'global' or 'workspace'
+        agent_id: The agent identifier
+        workspace_slug: Required when scope is 'workspace'
+    
+    Returns:
+        Path string if directory exists, None otherwise
+    """
+    if scope == "global":
+        path = os.path.join(
+            get_user_dir(), "Resources", "agent-skills", "global", agent_id, "skills"
+        )
+    elif scope == "workspace" and workspace_slug:
+        path = os.path.join(
+            get_user_dir(), "Resources", "agent-skills", "workspaces", workspace_slug, agent_id, "skills"
+        )
+    else:
+        return None
+    
+    return path if os.path.isdir(path) else None
+
+class RealTimeXAgent():
+    def __init__(
+        self, current_session_id
+    ):
+        self.agent_id: str = None
+        self.agent_data: Dict = None
+        self.agent: AnyAgent = None
+        self.agent_name: str = None
+        self.system_prompt: str = None
+        self.agent_framework: str = None
+        self.agent_description: str = None
+        self.default_model:str = None
+        self.recommended_agent_flows = None
+        self.recommended_aci_mcp_apps = None
+        self.recommended_local_mcp_apps = None
+        self.recommended_team_members = None
+        self.memory:Memory = None
+
+        self.current_session_id = current_session_id
+
+    async def prepare_llm(self, provider_name,model_name,api_base,api_key):
+        def get_provider_name(provider_name):
+            if provider_name == "realtimexai":
+                return "openai"
+            elif provider_name == "litellm":
+                return "openai"
+            elif provider_name == "openai":
+                return "openai"
+            elif provider_name == "ollama":
+                return "ollama"
+            elif provider_name == "gemini":
+                return "google"
+            elif provider_name == "google":
+                return "google"
+        
+        def get_model_name(model_name):
+            return model_name
+
+        provider_name = get_provider_name(provider_name)
+        model_name = get_model_name(model_name)
+
+        # if provider_name == "openai":
+        #     os.environ['OPENAI_BASE_URL'] = api_base
+        #     os.environ['OPENAI_API_KEY'] = api_key
+
+        # return {
+        #     "api_base": api_base,
+        #     "api_key": api_key,
+        #     "model_id": f"{provider_name}:{model_name}"
+        # }
+
+        return {
+            "api_base": api_base,
+            "api_key": api_key,
+            "model_id": f"{provider_name}/{model_name}"
+        }
+
+        # return {
+        #     "api_base": api_base,
+        #     "api_key": api_key,
+        #     "model_id": model_name
+        # }
+
+    async def create_subagents(self,instructions=None,tools=[],llm_config=None):
+        from openai import OpenAI
+        client = OpenAI(
+            api_key=llm_config["api_key"],
+            base_url=llm_config["api_base"],
+        )
+
+        system_prompt = self.system_prompt
+        if not instructions:
+            system_prompt = instructions
+        
+        schema = {
+            "title": "subagents",
+            "description": "The list of subagents to do the task well and effectively.",
+            "required": [
+                "subagents",
+            ],
+            "type": "object",
+            "properties": {
+                "subagents":{
+                    "type": "array",
+                    "description": "The list of subagents to do the task well and effectively.",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "name": {
+                                "type": "string",
+                                "description": "The name of the sub-agent"
+                            },
+                            "description": {
+                                "type": "string",
+                                "description": "A description of the sub-agent"
+                            },
+                            "prompt": {
+                                "type": "string",
+                                "description": "The prompt used by the sub-agent"
+                            },
+                            # "tools": {
+                            #     "type": "array",
+                            #     "description": "Optional list of tools name the sub-agent can use",
+                            #     "items": {
+                            #         "type": "string"
+                            #     }
+                            # }
+                        },
+                        "required": ["name", "description", "prompt"],
+                        "additionalProperties": False
+                    }
+                }
+            },
+            "additionalProperties": False
+        }
+
+        # print("schema", json.dumps(schema))
+
+        response_format = { "type": "json_schema", "json_schema": {"strict": True, "name": schema["title"], "schema": schema}}
+
+#         tools_str = ""
+#         for tool in tools:
+#             tools_str = f"""{tools_str}
+#   - {tool.__name__}: {tool.__doc__}"""
+
+        completion = client.beta.chat.completions.parse(
+            model=llm_config["model_id"],
+            messages=[{"role": "system", "content": 
+f"""You are tasked with designing a small team of specialized subagents to work together under the guidance of the main agent.
+
+* The main agent’s role and purpose is defined by:
+  {system_prompt}
+
+Your job is to create **no more than 5 subagents**. Each subagent must include:
+
+1. Name: lowercase, short, clear, and distinct, only alphabets and underscore allowed.
+2. Description: what this subagent is specialized at and how it contributes to the team.
+3. System Prompt: clear instructions that define the subagent’s behavior, style, and responsibilities.
+
+Guidelines:
+
+* Each subagent should have a well-defined, non-overlapping role.
+* The team should collectively cover all major aspects required for the main agent’s purpose.
+* Avoid redundancy—each subagent must bring unique value.
+* Keep the team **small (≤5 subagents)** but **effective**.
+
+Finally, return the result as a list of subagent objects in JSON format."""},
+                {"role": "user", "content": "Create a team of subagents to do task: {}"},
+            ],
+
+            response_format=response_format,
+        )
+
+
+
+        result = json.loads(completion.choices[0].message.content)
+
+        return result["subagents"]
+            
+        
+    async def prepare_realtimex_agent(self, agent_id, agent_data):
+        # directus_client = DirectusClient(server_url = directus_server_url,access_token = directus_access_token)
+
+        # d_agent = directus_client.get_directus_item_by_id("realtimex_agents",agent_id)
+
+        agent_name = agent_data["name"]
+        agent_description = agent_data["description"]
+        system_prompt = agent_data["instructions"]
+        agent_framework = agent_data["execution_config"]["framework"]
+        default_model = agent_data["execution_config"]["models"]["default_model"]
+
+        recommended_agent_flows = None
+        if "recommended_agent_flows" in agent_data:
+            recommended_agent_flows = agent_data["recommended_agent_flows"]
+
+        recommended_aci_mcp_apps = None
+        if "recommended_aci_mcp_apps" in agent_data:
+            recommended_aci_mcp_apps = agent_data["recommended_aci_mcp_apps"]
+
+        recommended_local_mcp_apps = None
+        if "recommended_local_mcp_apps" in agent_data:
+            recommended_local_mcp_apps = agent_data["recommended_local_mcp_apps"]
+            
+        recommended_team_members = None
+        if "recommended_team_members" in agent_data:
+            recommended_team_members = agent_data["recommended_team_members"]
+
+        self.agent_name = agent_name
+        self.system_prompt = system_prompt
+        self.agent_framework = agent_framework
+        self.agent_description = agent_description
+        self.default_model = default_model
+        self.agent_id = agent_id
+        self.agent_data = agent_data
+        self.recommended_agent_flows = recommended_agent_flows
+        self.recommended_aci_mcp_apps = recommended_aci_mcp_apps
+        self.recommended_local_mcp_apps = recommended_local_mcp_apps
+        self.recommended_team_members = recommended_team_members
+
+    async def prepare_memory(self,memory_id, memory_path, litellm_base_url, litellm_api_key):
+        pass
+        # config_dict = {
+        #     "version": "v1.1",
+        #     "vector_store": {
+        #         "provider": "chroma",
+        #         "config": {
+        #             "collection_name": memory_id,
+        #             "path": memory_path,
+        #         }
+        #     },
+        #     "llm": {"provider": "openai", "config": {"api_key": litellm_api_key, "openai_base_url": litellm_base_url, "temperature": 0.2, "model": "gpt-4o-mini"}},
+        #     "embedder": {"provider": "openai", "config": {"api_key": litellm_api_key, "openai_base_url": litellm_base_url, "model": "text-embedding-3-small"}},
+        #     "history_db_path": "",
+        # }
+        # print("config_dict",config_dict)
+        # memory = Memory.from_config(config_dict=config_dict)
+        # self.memory = memory
+
+    async def load_default_callbacks(self):
+        return [ShowToolCalling(),*get_default_callbacks()]
+
+    async def load_default_tools(self):
+        return []
+
+    async def load_aci_mcp_tools(self, linked_account_owner_id, aci_api_key):
+        from any_agent.config import MCPStdio
+        mcp_apps = []
+        for app in self.recommended_aci_mcp_apps:
+            if "realtimex_mcp_server_id" in app:
+                mcp_apps.append(app["realtimex_mcp_server_id"]["name"])
+            else:
+                mcp_apps.append(app["name"])
+        # mcp_apps = [app["realtimex_mcp_server_id"]["name"] for app in self.recommended_aci_mcp_apps]
+        if len(mcp_apps)>0:
+            mcp = MCPStdio(
+                # command=get_uvx_executable(),
+                # args=["aci-mcp@latest", 'apps-server', '--apps', ','.join(mcp_apps) , '--linked-account-owner-id', linked_account_owner_id],
+                command="aci-mcp",
+                args=['apps-server', '--apps', ','.join(mcp_apps) , '--linked-account-owner-id', linked_account_owner_id],
+                client_session_timeout_seconds=300,
+                env={
+                    "ACI_SERVER_URL":"https://mcp.realtimex.ai/v1/",
+                    "ACI_API_KEY":aci_api_key
+                }
+            )
+            return mcp
+        return None
+
+    async def load_local_mcp_tools(self):
+        from any_agent.config import MCPStdio
+        mcp_apps = [app["config"] for app in self.recommended_local_mcp_apps]
+        # mcp_apps = [
+        #     {"command":"uvx","args":["mcp-shell-server"],"env":{"ALLOW_COMMANDS":"ls,cat,pwd,grep,wc,touch,find"}}
+        # ]
+        mcps = []
+        default_env = {
+            'NVM_INC': get_nvm_inc(),
+            'NVM_CD_FLAGS': '-q',
+            'NVM_DIR': get_nvm_dir(),
+            'PATH': f'{os.environ.copy()["PATH"]}{os.pathsep}{get_nvm_bin()}',
+            'NVM_BIN': get_nvm_bin()
+        }
+        for mcp_app in mcp_apps:
+            if mcp_app["command"] == "uvx":
+                mcp_app["command"] = get_uvx_executable()
+            if mcp_app["command"] == "npx":
+                mcp_app["command"] = get_npx_executable()
+            if "env" not in mcp_app:
+                mcp_app["env"] = {}
+            mcp_app["env"] = {**mcp_app["env"],**default_env}
+            # print("mcp_app",mcp_app)
+            mcp = MCPStdio(
+                **mcp_app,
+                client_session_timeout_seconds=300,
+            )
+            mcps.append(mcp)
+        return mcps
+
+    async def load_mcp_agent_flow_tools(self, linked_account_owner_id, aci_api_key, litellm_base_url, litellm_api_key, realtimex_access_token, workspace_slug, thread_id):
+        from any_agent.config import MCPStdio
+        agent_flow_ids = [flow["realtimex_agent_flows_id"]["id"] for flow in self.recommended_agent_flows]
+        if len(agent_flow_ids)>0:
+            mcp = MCPStdio(
+                # command=get_uvx_executable(),
+                # args=["--from", "git+https://oauth2:5yTHSE9k34jbWgzXmsxQ@rtgit.rta.vn/rtlab/rtwebteam/mcp-servers/realtimex-ai-agent-flows@main","agent-flows-mcp-server",'--flows',','.join(agent_flow_ids)],
+                command="agent-flows-mcp-server",
+                args=['--flows',','.join(agent_flow_ids)],
+                client_session_timeout_seconds=300,
+                env={
+                    "AGENT_FLOWS_API_KEY": realtimex_access_token,
+                    "LITELLM_API_KEY": litellm_api_key,
+                    "LITELLM_API_BASE": litellm_base_url,
+                    "MCP_ACI_API_KEY": aci_api_key,
+                    "MCP_ACI_LINKED_ACCOUNT_OWNER_ID": linked_account_owner_id,
+                    "SESSION_ID": self.current_session_id,
+                    "WORKSPACE_SLUG": workspace_slug,
+                    "THREAD_ID": thread_id
+                    # "AGENT_FLOWS_BASE_URL": "https://your-custom-instance.com"  # Optional
+                }
+            )
+            return mcp
+        return None
+
+    async def load_a2a_agents_as_tools(self):
+        def get_free_port():
+            import socket
+            sock = socket.socket()
+            sock.bind(('', 0))
+            return sock.getsockname()[1]
+
+    
+        tools = []
+        for a2a_agent in self.recommended_team_members:
+            agent_id = a2a_agent["agent_id"]
+            agent_data = a2a_agent["agent_data"]
+            a2a_port = get_free_port()
+            # Create agent
+            agent = RealTimeXAgent()
+
+            await agent.load_default_agent(agent_id, agent_data, payload=a2a_agent)
+            
+            agent_server_url = await agent.serve_as_a2a(
+                a2a_serving_config={"port":a2a_port,"stream_tool_usage":True},
+            )
+
+            # print(agent_server_url)
+
+            tools.append(
+                await a2a_tool_async(
+                    agent_server_url,
+                    http_kwargs={
+                        "timeout": 300
+                    },  # This gives the time agent up to 30 seconds to respond to each request
+                )
+            )
+
+
+        return tools
+
+    async def load_knowledges(self,query, user_id, workspace_slug, thread_id, knowledges=["thread"]):
+        memory_session_id = None
+        if "user" in knowledges:
+            memory_session_id = None
+        elif "workspace" in knowledges:
+            memory_session_id = workspace_slug
+        elif "thread" in knowledges:
+            memory_session_id = f"{workspace_slug}_{thread_id}"
+        # print("memory_session_id",memory_session_id)
+        history_memories = self.memory.search(query=query, user_id=user_id, run_id=memory_session_id,limit=5)
+        # history_memories = self.memory.get_all(user_id=user_id, run_id=memory_session_id,limit=20)
+        # print("history_memories",history_memories)
+        
+        memories_str = "\n".join(f"- {entry['memory']}" for entry in history_memories["results"])
+
+        knowledges_str = ""
+        all_knowledge_memories = []
+        for knowledge_id in knowledges:
+            if knowledge_id in ["account","workspace","thread"]:
+                continue
+            knowledge_memories = self.memory.search(query=query, user_id=user_id, run_id=knowledge_id, limit=5)
+            all_knowledge_memories = [*all_knowledge_memories,*knowledge_memories["results"]]
+
+        knowledges_str = "\n".join(f"- {entry['memory']}" for entry in all_knowledge_memories)
+        return memories_str, knowledges_str
+
+
+    async def create_agent(self, agent_framework="tinyagent",agent_config=None,tools=[],callbacks=[], memories_str=None, knowledges_str=None):
+        default_agent_config = {
+            "name": self.agent_name,
+            "model_id": self.default_model,
+            "description": self.agent_description,
+            "instructions": self.system_prompt,
+            "tools": tools,
+            "callbacks": callbacks
+        }
+
+        default_agent_framework = self.agent_framework
+
+        if agent_config:
+            default_agent_config.update(agent_config)
+
+        if agent_framework:
+            default_agent_framework = agent_framework
+        
+        # print("default_agent_config", default_agent_config)
+        # print("agent_config", agent_config)
+
+        if memories_str:
+            default_agent_config["instructions"] = default_agent_config["instructions"].replace("##MEMORIES##",memories_str)
+        if knowledges_str:
+            default_agent_config["instructions"] = default_agent_config["instructions"].replace("##KNOWLEDGES##",knowledges_str)
+        # print(default_agent_framework)
+        # print(default_agent_config)
+
+        self.agent = await AnyAgent.create_async(
+            default_agent_framework,  # See all options in https://mozilla-ai.github.io/any-agent/
+            AgentConfig(
+                **default_agent_config,
+                current_session_id=self.current_session_id,
+                # agent_args={
+                #     "interrupt_after":["get_user_info"]
+                # }
+            ),
+        )
+        
+        return self.agent
+    
+    async def serve_as_a2a(self, a2a_serving_config):
+        handle = await self.agent.serve_async(A2AServingConfig(**a2a_serving_config))
+        server_port = handle.port
+        server_url = f"http://localhost:{server_port}"
+
+        return server_url
+
+    async def load_default_agent(self, agent_id, agent_data, payload):
+        system_prompt = None
+        agent_framework = None
+        agent_description = None
+        agent_name = None
+        default_model = None
+        provider_name = None
+        llm_setting = None
+
+        user_id = payload["user_id"]
+        workspace_slug = payload["workspace_slug"]
+        thread_id = payload["thread_id"]
+        knowledges = payload["knowledges"]
+        memory_id = payload["memory_id"]
+        memory_path = payload["memory_path"]
+        execution_id = payload["session_id"]
+        aci_linked_account_owner_id = payload["aci_linked_account_owner_id"]
+        aci_agent_first_api_key = payload["aci_api_key"]
+        realtimex_access_token = payload["realtimex_access_token"]
+
+        agent_description = agent_data["description"]
+        agent_name = agent_data["name"]
+        agent_framework = agent_data["execution_config"]["framework"]
+
+        if "agent_description" in payload:
+            agent_description = payload["agent_description"]
+        if "agent_name" in payload:
+            agent_name = payload["agent_name"]
+        if "agent_framework" in payload:
+            agent_framework = payload["agent_framework"]
+        if "system_prompt" in payload:
+            system_prompt = payload["system_prompt"]
+        if "llm_setting" in payload:
+            llm_setting = payload["llm_setting"]            
+            
+
+        default_openai_base_url = payload["litellm_api_base"]
+        default_openai_api_key = payload["litellm_api_key"]
+
+        # Load MCP tools
+        
+        # # Create agent
+        # agent = RealTimeXAgent()
+
+        # print("agent_data")
+
+        await self.prepare_realtimex_agent(
+            agent_id=agent_id,
+            agent_data=agent_data
+        )
+        
+        # await self.prepare_memory(memory_id=memory_id, memory_path=memory_path, litellm_base_url=default_openai_base_url, litellm_api_key=default_openai_api_key)
+
+        default_callbacks = await self.load_default_callbacks()
+        
+        default_tools = await self.load_default_tools()
+        all_tools = [*default_tools]
+        
+        if self.recommended_aci_mcp_apps:
+            aci_mcp = await self.load_aci_mcp_tools(
+                linked_account_owner_id=aci_linked_account_owner_id,
+                aci_api_key=aci_agent_first_api_key
+            )
+            if aci_mcp:
+                all_tools = [*all_tools,aci_mcp]
+
+        if self.recommended_local_mcp_apps:
+            local_mcps = await self.load_local_mcp_tools()
+            # print("local_mcps",local_mcps)
+            all_tools = [*all_tools,*local_mcps]
+
+        if self.recommended_agent_flows:
+            aci_mcp_agent_flow = await self.load_mcp_agent_flow_tools(
+                linked_account_owner_id=aci_linked_account_owner_id,
+                aci_api_key=aci_agent_first_api_key,
+                realtimex_access_token=realtimex_access_token,
+                litellm_base_url=default_openai_base_url,
+                litellm_api_key=default_openai_api_key,
+                workspace_slug=workspace_slug,
+                thread_id=thread_id
+            )
+            if aci_mcp_agent_flow:
+                all_tools = [*all_tools,aci_mcp_agent_flow]
+
+        if self.recommended_team_members:
+            
+            team_members = await self.load_a2a_agents_as_tools()
+            # print(team_members)
+            if team_members:
+                all_tools = [*all_tools,*team_members]
+
+        
+
+        agent_config = {
+            "api_base": default_openai_base_url,
+            "api_key": default_openai_api_key,
+        }
+
+        # print("agent_framework",agent_framework)
+
+        if agent_description:
+            agent_config["description"] = agent_description
+        if system_prompt:
+            agent_config["instructions"] = system_prompt
+
+
+        if llm_setting:
+            llm_config = await self.prepare_llm(**llm_setting["default"])
+            # print("llm_config",llm_config)
+            agent_config.update(llm_config)
+
+
+        memories_str = ""
+        knowledges_str = ""
+        # if knowledges:
+        #     memories_str, knowledges_str = await self.load_knowledges(message, user_id, workspace_slug, thread_id, knowledges)
+
+        if agent_framework == "deepagents":
+            from deepagents import create_realtimex_deep_agent
+            from deepagents.backends import CompositeBackend
+            from deepagents.backends.filesystem import FilesystemBackend
+            agent_framework = "langchain"
+            agent_config["agent_type"] = create_realtimex_deep_agent
+
+            # Backend is always required for deepagents
+            agent_config["agent_args"] = {
+                "assistant_id": agent_id,
+                "backend": CompositeBackend(
+                    default=FilesystemBackend(),
+                    routes={},
+                )
+            }
+
+            # Resolve memory paths (global and workspace)
+            global_agent_path = get_deepagents_agent_path("global", agent_id)
+            workspace_agent_path = get_deepagents_agent_path("workspace", agent_id, workspace_slug)
+            
+            # Enable memory if either global or workspace config exists
+            agent_config["agent_args"]["enable_memory"] = bool(global_agent_path or workspace_agent_path)
+            if global_agent_path:
+                agent_config["agent_args"]["global_agent_path"] = global_agent_path
+            if workspace_agent_path:
+                agent_config["agent_args"]["workspace_agent_path"] = workspace_agent_path
+
+            # Resolve skills paths (global and workspace)
+            global_skills_dir = get_deepagents_skills_dir("global", agent_id)
+            workspace_skills_dir = get_deepagents_skills_dir("workspace", agent_id, workspace_slug)
+            
+            # Enable skills if either global or workspace config exists
+            agent_config["agent_args"]["enable_skills"] = bool(global_skills_dir or workspace_skills_dir)
+            if global_skills_dir:
+                agent_config["agent_args"]["global_skills_dir"] = global_skills_dir
+            if workspace_skills_dir:
+                agent_config["agent_args"]["workspace_skills_dir"] = workspace_skills_dir
+
+            if "subagents" in agent_data["execution_config"]:
+                if "_auto" in agent_data["execution_config"]["subagents"]:
+                    try:
+                        subagents = await self.create_subagents(
+                            instructions=system_prompt,
+                            tools=[],
+                            llm_config={
+                                "api_base": agent_config["api_base"],
+                                "api_key": agent_config["api_key"],
+                                "model_id": agent_config["model_id"]
+                            }
+                        )
+                        if subagents:
+                            # Merge subagents into existing agent_args if present
+                            if "agent_args" not in agent_config:
+                                agent_config["agent_args"] = {}
+                            agent_config["agent_args"]["subagents"] = subagents
+                    except Exception as e:
+                        print(e)
+                        
+                    # print(agent_config["agent_args"])
+
+        await self.create_agent(
+            agent_framework=agent_framework,  # See all options in https://mozilla-ai.github.io/any-agent/
+            agent_config=agent_config,
+            tools=all_tools,
+            callbacks=[*default_callbacks],
+            memories_str=memories_str,
+            knowledges_str=knowledges_str
+        )
+
+        # return agent

realtimex_agent_a2a_agent-0.2.0/src/realtimex_agent_a2a_agent/callbacks/tool_execution.py

@@ -0,0 +1,249 @@
+from uuid import uuid4
+import json
+import time
+import os
+import redis
+import sys
+
+from any_agent.callbacks import Callback, Context
+from any_agent.tracing.attributes import GenAI
+
+pool = redis.ConnectionPool(host='127.0.0.1', port=6379, db=1)
+r = redis.Redis(connection_pool=pool)
+
+class ShowToolCalling(Callback):
+    def before_tool_execution(self, context: Context, *args, **kwargs) -> Context:
+        span = context.current_span
+
+        operation_name = span.attributes.get(GenAI.OPERATION_NAME, "")
+
+        if operation_name != "execute_tool":
+            return context
+
+        tool_name = span.attributes.get(GenAI.TOOL_NAME, "")
+        tool_input = span.attributes.get(GenAI.TOOL_ARGS, "{}")
+        tool_call_id = span.attributes.get("gen_ai.tool.call.id","")
+
+        toolName = tool_name
+        toolIcon = "pencil-ruler"
+        mainTask = "Tool is executing..."
+
+        if tool_name.startswith("call_"):
+            toolIcon = "bot"
+            toolName = f"Call sub-agent {tool_name.replace('call_','')}"
+            mainTask = "Sub-agent is working..."
+
+        if tool_name == "final_answer":
+            return context
+
+        block_id = str(uuid4())
+        context.shared[f"show_tool_calling_block_id_{tool_call_id}"] = block_id
+        context.shared[f"show_tool_calling_start_time_{tool_call_id}"] = round(time.time() * 1000)
+        
+        current_session_id = None
+        if "_current_session_id" in context.shared:
+            current_session_id = context.shared['_current_session_id']
+
+        print("current_session_id", current_session_id)
+
+        message_content = {
+            "uuid": str(uuid4()),
+            "type": "responseData",
+            "dataType": "toolUse",
+            "data": {
+                "toolName": toolName,
+                "toolIcon": toolIcon,
+                "mainTask" : mainTask,
+                "input": [tool_input],
+                "content": "",
+                "meta": {"blockId":block_id, "status": "processing", "durationMs": 0 }
+            }
+        }
+
+        if message_content:
+            # print(f"<message>{json.dumps(message_content)}</message>")
+            pub = r.publish(
+                current_session_id,
+                f'.message {json.dumps(message_content)}'
+            )
+
+        return context
+
+
+
+    def after_tool_execution(self, context: Context, *args, **kwargs) -> Context:
+        span = context.current_span
+
+        operation_name = span.attributes.get(GenAI.OPERATION_NAME, "")
+
+        if operation_name != "execute_tool":
+            return context
+
+        tool_name = span.attributes.get(GenAI.TOOL_NAME, "")
+        tool_input = span.attributes.get(GenAI.TOOL_ARGS, "{}")
+        tool_call_id = span.attributes.get("gen_ai.tool.call.id","")
+
+        toolName = tool_name
+        toolIcon = "pencil-ruler"
+        mainTask = "Tool executed completely."
+
+        if tool_name.startswith("call_"):
+            toolIcon = "bot"
+            toolName = f"Call sub-agent {tool_name.replace('call_','')}"
+            mainTask = "Sub-agent has completed the task."
+
+        # if tool_name == "final_answer":
+        #     return context
+
+        if f"show_tool_calling_block_id_{tool_call_id}" in context.shared:
+            block_id = context.shared[f"show_tool_calling_block_id_{tool_call_id}"]
+        else:
+            block_id = str(uuid4())
+        
+        execution_time = 0
+        if f"show_tool_calling_start_time_{tool_call_id}" in context.shared:
+            execution_time = round(time.time() * 1000) - context.shared[f"show_tool_calling_start_time_{tool_call_id}"]
+        else:
+            execution_time = 1000
+
+        current_session_id = None
+        if "_current_session_id" in context.shared:
+            current_session_id = context.shared['_current_session_id']
+
+        # print("current_session_id", current_session_id)
+
+        # context.shared[f"show_tool_calling_start_time_{tool_call_id}"] = round(time.time() * 1000)
+        ui_components = []
+        flow_as_output = False
+        flow_output_data = None
+
+        message_content = None
+        if output := span.attributes.get(GenAI.OUTPUT, None):
+            output_type = span.attributes.get(GenAI.OUTPUT_TYPE, "text")
+
+            if toolName == "final_answer":
+                # message_content = {
+                #     "uuid": str(uuid4()),
+                #     "type": "responseData",
+                #     "content": output,
+                #     "dataType": "markdown",
+                #     "data": {"content": output, "language": None},
+                # }
+                # pub = r.publish(
+                #     current_session_id,
+                #     f'.message {json.dumps(message_content)}'
+                # )
+                return context
+
+
+            if output_type == "json":
+                output_data = json.loads(output)
+
+                if "ui-components" in output_data:
+                    if output_data["ui-components"]:
+                        for ui_component in output_data["ui-components"]:
+                            ui_component["uuid"] = str(uuid4())
+                            ui_component["type"] = "responseData"
+                            ui_components.append(ui_component)
+
+                    del output_data['ui-components']
+                
+                if "flow_as_output" in output_data:
+                    if output_data["flow_as_output"]:
+                        flow_as_output = True
+                        if "output" in output_data:
+                            flow_output_data = str(output_data["output"])
+
+                message_content = {
+                    "uuid": str(uuid4()),
+                    "type": "responseData",
+                    "dataType": "toolUse",
+                    "data": {
+                        "toolName": toolName,
+                        "toolIcon": toolIcon,
+                        "mainTask" : mainTask,
+                        "input": [tool_input],
+                        "content": {
+                            "dataType": "json",
+                            "data": {
+                                "content": output_data, 
+                                "language": None
+                            }
+                        },
+                        "meta": {"blockId":block_id, "status": "completed", "durationMs": execution_time }
+                    }
+                }
+                    
+
+            else:
+                message_content = {
+                    "uuid": str(uuid4()),
+                    "type": "responseData",
+                    "dataType": "toolUse",
+                    "data": {
+                        "toolName": toolName,
+                        "toolIcon": toolIcon,
+                        "mainTask" : mainTask,
+                        "input": [tool_input],
+                        "content": {
+                            "dataType": "markdown",
+                            "data": {
+                                "content": output, 
+                                "language": None
+                            }
+                        },
+                        "meta": {"blockId":block_id, "status": "completed", "durationMs": execution_time }
+                    }
+                }
+        else:
+            message_content = {
+                "uuid": str(uuid4()),
+                "type": "responseData",
+                "dataType": "toolUse",
+                "data": {
+                    "toolName": toolName,
+                    "toolIcon": toolIcon,
+                    "mainTask" : mainTask,
+                    "input": [tool_input],
+                    "content": {
+                        "dataType": "markdown",
+                        "data": {
+                            "content": "No outputs.", 
+                            "language": None
+                        }
+                    },
+                    "meta": {"blockId":block_id, "status": "completed", "durationMs": execution_time }
+                }
+            }
+
+        if message_content:
+            # print(f"<message>{json.dumps(message_content)}</message>")
+            pub = r.publish(
+                current_session_id,
+                f'.message {json.dumps(message_content)}'
+            )
+        if len(ui_components) > 0:
+            for ui_component in ui_components:
+                pub = r.publish(
+                    current_session_id,
+                    f'.message {json.dumps(ui_component)}'
+                )
+
+        if flow_as_output:
+            pass
+            # message_content = {
+            #     "uuid": str(uuid4()),
+            #     "type": "responseData",
+            #     "dataType": "markdown",
+            #     "data": {
+            #         "content": flow_output_data, 
+            #         "language": None
+            #     }
+            # }
+            # pub = r.publish(
+            #     current_session_id,
+            #     f'.message {json.dumps(message_content)}'
+            # )
+            # raise RuntimeError("Reached Return Direct Tool.")
+
+        return context

realtimex_agent_a2a_agent-0.2.0/src/realtimex_agent_a2a_agent/cli.py

@@ -0,0 +1,228 @@
+from datetime import datetime
+def print_time(text):
+    # Get the current date and time
+    now = datetime.now()
+
+    # Extract and print only the time
+    current_time = now.strftime("%H:%M:%S")
+    print(f"{text}: ", current_time)
+
+print_time("begin")
+
+from .agent import RealTimeXAgent
+ 
+import json
+import os
+import asyncio
+import httpx
+import sys
+# from inputimeout import inputimeout, TimeoutOccurred
+import threading
+
+from any_agent.serving import A2AServingConfig
+from any_agent import AgentConfig, AnyAgent
+
+from a2a.client import A2ACardResolver, A2AClient
+from a2a.types import AgentCard
+
+from uuid import uuid4
+
+from a2a.types import MessageSendParams, SendMessageRequest, TaskState
+
+print_time("after import")
+
+# Create the httpx client
+httpx_client = httpx.AsyncClient()
+
+import nest_asyncio
+
+nest_asyncio.apply()
+
+async def run():
+    print_time("begin run")
+    # Prepare kwargs
+    # print(sys.argv)
+    payload = json.loads(sys.argv[1])
+    # kwargs = {"workspace_slug": "test", "query": "hi", "messages": [{"role": "user", "content": "hi"}], "user_id": "user_14", "session_id": "500b4358-5d85-415d-acf0-8b12b4d896cc", "db_url": "sqlite:///C:\\Users\\Web team\\.realtimex.ai\\Resources/test_accounting_sessions.db", "default_model": "gpt-4o-mini", "litellm_api_key": "sk-tYJFmnnGzFpI9Tr1735989A9252944A9A8960c95FcCaD9Bc", "litellm_api_base": "https://llm.realtimex.ai/v1", "aci_linked_account_owner_id": "3e0bb6de-d64e-41f4-8cc7-f01a00398826", "aci_api_key": "b3bc24bb36ec940309e0dc31e22578f711b64038c7091ae92d59890dd03480a0", "agent_id": "63a42f8d-239d-4e2e-82bd-016d54110a90", "agent_data": {"name": "test-agent", "description": "Default RealTimeX Agent", "instructions": "You are the agent - please keep going until the user's query is completely resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the problem is solved, or if you need more info from the user to solve the problem.\n\nALWAYS ask required inputs from user to make sure to have correct inputs while calling functions.\n\nIf you are not sure about anything pertaining to the user's request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.\n\nYou MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.\n\nRELATED MEMORIES:\n{##MEMORIES##}\n\nRELATED KNOWLEDGES:\n{##KNOWLEDGES##}", "execution_config": {"cmd": ["uvx", "realtimex-agent-a2a-agent"], "data": {}, "models": {"provider": "realtimexai", "default_model": "gpt-3.5-turbo"}, "framework": "tinyagent"}, "recommended_agent_flows": [], "recommended_aci_mcp_apps": []}, "thread_id": None, "knowledges": [], "memory_id": "aab7f86e-8f94-46a2-9f16-5bf0c58902dc", "memory_path": "C:\\Users\\Web team\\.realtimex.ai\\memories", "realtimex_access_token": "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJORlVmWGlMZHlxVmtSdGFJUlFGVGlZVXZBWXUwdXpSSXp2OEZaTGpnbGdnIn0.eyJleHAiOjE3NTYyODE2ODgsImlhdCI6MTc1NjI4MDc4OCwiYXV0aF90aW1lIjoxNzU2MTczNTA4LCJqdGkiOiI5NWRkYmFlNy03YmFjLTRlMzgtYTBlNi1kNDg0ODJkNWM2YjUiLCJpc3MiOiJodHRwczovL2FjY291bnRzLnJlYWx0aW1leC5jby9hdXRoL3JlYWxtcy9yZWFsdGltZXgiLCJhdWQiOiJhY2NvdW50Iiwic3ViIjoiMGNhYTM5ZmItYzRiOS00MzYzLTljMmMtYWZjNDQ4ZDUyZjkwIiwidHlwIjoiQmVhcmVyIiwiYXpwIjoicmVhbHRpbWV4LWFwcCIsIm5vbmNlIjoiY2Y0NGE3ZDctYjAyMy00NmQyLTllODktNDgyNmU0MGUxZDdmIiwic2Vzc2lvbl9zdGF0ZSI6IjEzOTRlZmRmLWEyZmMtNDgzMS1hM2FlLTBkYzgwNTMzZWVlNiIsImFjciI6IjEiLCJhbGxvd2VkLW9yaWdpbnMiOlsiKiJdLCJyZWFsbV9hY2Nlc3MiOnsicm9sZXMiOlsib2ZmbGluZV9hY2Nlc3MiLCJ1bWFfYXV0aG9yaXphdGlvbiIsImRlZmF1bHQtcm9sZXMtcnR3b3JrLWluYyJdfSwicmVzb3VyY2VfYWNjZXNzIjp7ImFjY291bnQiOnsicm9sZXMiOlsibWFuYWdlLWFjY291bnQiLCJtYW5hZ2UtYWNjb3VudC1saW5rcyIsInZpZXctcHJvZmlsZSJdfX0sInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIGVtYWlsIHByb2ZpbGUiLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwibmFtZSI6IlBodW9uZyBOZ3V5ZW4iLCJwcmVmZXJyZWRfdXNlcm5hbWUiOiJwaHVvbmdubTE1OTMiLCJnaXZlbl9uYW1lIjoiUGh1b25nIiwiZmFtaWx5X25hbWUiOiJOZ3V5ZW4iLCJlbWFpbCI6InBodW9uZ25tMTU5M0BnbWFpbC5jb20ifQ.jYWqbKAvXND5fACOBCsi6PPJkU7yDGwnqgJ-qSn0Wz2hSzRYl4Gymc2HSlLASO4aDO24Ar7Ob4R26xpAyfkXMjFWHR94MxajK9CZlVfV4NOpVCRXq1R--3aNA1oNWu-FbRMDKNQIJDd1se2fjJfMa79C9yVXlUs2R_-1ktTHjBnblsWkkh2p8frGNKsLq_kacXpV4YGe5IAf96z5XfYJKTV2ykVFPV67f5-brlNfXLBx88I0ZGY41K_VCkoL0wsHUB1FlBjHzfomsRfHrjMzrIFvx1B6tIV-kLOnjeuDZdysmtjR0L7w4gKsXxRl2bV8B0lWqHknytEnvciMZduDEQ"}
+
+    a2a_port = sys.argv[2]
+
+    system_prompt = None
+    agent_framework = None
+    agent_description = None
+    default_model = None
+    provider_name = None
+    llm_setting = None
+
+    agent_id = payload["agent_id"]
+    agent_data = payload["agent_data"]
+    user_id = payload["user_id"]
+    workspace_slug = payload["workspace_slug"]
+    thread_id = payload["thread_id"]
+    knowledges = payload["knowledges"]
+    memory_id = payload["memory_id"]
+    memory_path = payload["memory_path"]
+    execution_id = payload["session_id"]
+    message = payload["query"]
+    messages = payload["messages"]
+    aci_linked_account_owner_id = payload["aci_linked_account_owner_id"]
+    aci_agent_first_api_key = payload["aci_api_key"]
+    realtimex_access_token = payload["realtimex_access_token"]
+
+
+    if "agent_description" in payload:
+        agent_description = payload["agent_description"]
+    if "agent_framework" in payload:
+        agent_framework = payload["agent_framework"]
+    if "system_prompt" in payload:
+        system_prompt = payload["system_prompt"]
+    if "llm_setting" in payload:
+        llm_setting = payload["llm_setting"]
+
+    default_openai_base_url = payload["litellm_api_base"]
+    default_openai_api_key = payload["litellm_api_key"]
+
+    # Load MCP tools
+    
+    # Create agent
+    agent = RealTimeXAgent(current_session_id=execution_id)
+
+    await agent.load_default_agent(agent_id, agent_data, payload)
+    
+    server_url = await agent.serve_as_a2a(
+        a2a_serving_config={"port":a2a_port,"stream_tool_usage":True}
+    )
+
+    print(f"<server-url>{server_url}</server-url>")
+
+    # input("Waiting...")
+
+    # async with httpx.AsyncClient() as client:
+    #     while True:
+    #         try:
+    #             await client.get(server_url, timeout=1.0)
+    #             print(f"Server is ready at {server_url}")
+
+    #             agent_card: AgentCard = await A2ACardResolver(
+    #                 httpx_client,
+    #                 base_url=server_url,
+    #             ).get_agent_card(http_kwargs=None)
+    #             # print(agent_card.model_dump_json(indent=2))
+
+    #             client = A2AClient(httpx_client=httpx_client, agent_card=agent_card)
+
+    #             send_message_payload = {
+    #                 "message": {
+    #                     "role": "user",
+    #                     "parts": [{"kind": "text", "text": f"{message}"}],
+    #                     "messageId": uuid4().hex,
+    #                     # "contextId": "bce7de7a-5050-4b74-822c-af0e13073036",  # Same context to continue conversation
+    #                     # "taskId": "159e8a1b-788c-47ef-998d-9419b8f5fb5a",  # type: ignore[union-attr]
+    #                 },
+    #             }
+    #             request = SendMessageRequest(
+    #                 id=str(uuid4()), params=MessageSendParams(**send_message_payload)
+    #             )
+    #             response = await client.send_message(request, http_kwargs={"timeout": 300.0})
+    #             print("response",response)
+    #             # response = json.loads(response.root.result.status.message.parts[0].root.text)
+    #             # # print(response["result"])
+    #             # print("response",response)
+    #             response_message = response.root.result.status.message
+    #             response_text = json.loads(response_message.parts[0].root.text)["result"]
+    #             response_state = response.root.result.status.state
+    #             context_id = response.root.result.context_id
+    #             task_id = response.root.result.id
+
+    #             message_content = {
+    #                 "uuid": str(uuid4()),
+    #                 "type": "responseData",
+    #                 "content": response_text,
+    #                 "dataType": "markdown",
+    #                 "data": {"content": response_text, "language": None},
+    #             }
+
+    #             print(f"<message>{json.dumps(message_content)}</message>")
+    #             print(f"<signal>session-end</signal>")
+
+                
+                
+    #             # while response_state == TaskState.input_required:
+    #             while True:
+    #                 # user_input = input(response_text)
+    #                 user_input = input('Enter message: ')
+    #                 if user_input is None:
+    #                     break
+                    
+    #                 if response_state == TaskState.completed:
+    #                     send_message_payload = {
+    #                         "message": {
+    #                             "role": "user",
+    #                             "parts": [{"kind": "text", "text": f"{user_input}"}],
+    #                             "messageId": uuid4().hex,
+    #                             "contextId": response.root.result.context_id,  # Same context to continue conversation
+    #                         },
+    #                     }
+    #                 else:
+    #                     send_message_payload = {
+    #                         "message": {
+    #                             "role": "user",
+    #                             "parts": [{"kind": "text", "text": f"{user_input}"}],
+    #                             "messageId": uuid4().hex,
+    #                             "contextId": response.root.result.context_id,  # Same context to continue conversation
+    #                             "taskId": response.root.result.id,  # type: ignore[union-attr]
+    #                         },
+    #                     }
+
+    #                 request = SendMessageRequest(
+    #                     id=str(uuid4()), params=MessageSendParams(**send_message_payload)
+    #                 )
+    #                 response = await client.send_message(request, http_kwargs={"timeout": 300.0})
+
+    #                 print("send_message_payload",send_message_payload)
+    #                 print("response",response)
+
+    #                 response_message = response.root.result.status.message
+    #                 response_text = json.loads(response_message.parts[0].root.text)["result"]
+    #                 response_state = response.root.result.status.state
+
+    #                 message_content = {
+    #                     "uuid": str(uuid4()),
+    #                     "type": "responseData",
+    #                     "content": response_text,
+    #                     "dataType": "markdown",
+    #                     "data": {"content": response_text, "language": None},
+    #                 }
+
+    #                 print(f"<message>{json.dumps(message_content)}</message>")
+    #                 print(f"<signal>session-end</signal>")
+
+
+                
+
+    #             # print(response)
+    #             # Close the httpx client when done
+    #             await httpx_client.aclose()
+
+    #             break
+    #         except (httpx.RequestError, httpx.TimeoutException):
+    #             await asyncio.sleep(poll_interval)
+    #             attempts += 1
+    #             if attempts >= max_attempts:
+    #                 msg = f"Could not connect to {server_url}. Tried {max_attempts} times with {poll_interval} second interval."
+    #                 raise ConnectionError(msg)
+
+
+    async with httpx.AsyncClient() as client:
+        while True:
+            try:
+                await client.get(server_url, timeout=1.0)
+                print(f"<signal>server-listening</signal>")
+            except (httpx.RequestError, httpx.TimeoutException):
+                print(f"<signal>server-stopped</signal>")
+            await asyncio.sleep(30)
+
+
+def main():
+    print_time("begin main")
+    asyncio.run(run())

realtimex_agent_a2a_agent-0.2.0/src/realtimex_agent_a2a_agent/tools.py

@@ -0,0 +1,14 @@
+def send_email(body:str, to_email:str, from_email: str = "me") -> str:
+    """Send Email to someone.
+
+    Args:
+        from_email (str): The sender
+        to_email (str): The receiver email
+        body (str): The body of email
+
+    Returns:
+        The string to say hello.
+
+    """
+    
+    return f"Email has been sent to {to_email}"