realtimex-agent-a2a-agent 0.4.2__py3-none-any.whl

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/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/npx.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+export NVM_DIR=/Users/$(whoami)/.nvm
+source $NVM_DIR/nvm.sh
+
+npx "$@"

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}"

realtimex_agent_a2a_agent-0.4.2.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.3
+Name: realtimex-agent-a2a-agent
+Version: 0.4.2
+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.4.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+realtimex_agent_a2a_agent/__init__.py,sha256=8X_E69_hK92hxiMs2rIoxoq3eSV6aPkS5TQt0oCEVWI,69
+realtimex_agent_a2a_agent/agent copy.py,sha256=HScIX5FQIA2vTlM7ZA9rgySNHv1S3sAfDoTV_tAgRJ4,28811
+realtimex_agent_a2a_agent/agent.py,sha256=BGHMdaHNI_UbDetL5PFY2IpmGZ7lgvX7Ssaz4Qffnn8,30147
+realtimex_agent_a2a_agent/callbacks/tool_execution.py,sha256=Z4NxV7ZurjoKIhZBXWd62tWRhmHWsXOvn3iQPav8n3Y,9045
+realtimex_agent_a2a_agent/cli.py,sha256=EgpAatNJid4MFYR392uFULQBVGRxxHxUUj8r05vmMzk,12129
+realtimex_agent_a2a_agent/npx.sh,sha256=NZipbZxBEcEahWjWVnNaFHBwYNyvT6At-wLm0dkRNto,81
+realtimex_agent_a2a_agent/tools.py,sha256=tHMl1Y2cYEn9dNu_zvg59-k2h6FpUMNXcpmYIb_xTiI,339
+realtimex_agent_a2a_agent-0.4.2.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+realtimex_agent_a2a_agent-0.4.2.dist-info/entry_points.txt,sha256=Y0LpZt4GtWoM-0Kpn3H_ehehwttkMHGHXbj-nXzF1Nc,82
+realtimex_agent_a2a_agent-0.4.2.dist-info/METADATA,sha256=vb44Rs1wG6GlRZoJNfno8mxisdoLceOmrQKY_l8pSzw,608
+realtimex_agent_a2a_agent-0.4.2.dist-info/RECORD,,

realtimex_agent_a2a_agent-0.4.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any

realtimex_agent_a2a_agent-0.4.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+realtimex-agent-a2a-agent = realtimex_agent_a2a_agent.cli:main
+