pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/organization/responses.py

@@ -1,7 +1,7 @@
 from pydantic.main import BaseModel
 
 from pygeai.core.models import Assistant, Project, ProjectToken, \
-    RequestItem
+    RequestItem, Role, Member, OrganizationMembership, ProjectMembership, Organization
 
 
 class AssistantListResponse(BaseModel):
@@ -22,3 +22,60 @@ class ProjectTokensResponse(BaseModel):
 
 class ProjectItemListResponse(BaseModel):
     items: list[RequestItem]
+
+    def to_list(self):
+        return [item.to_dict() for item in self.items] if self.items else []
+
+    def __getitem__(self, index: int) -> RequestItem:
+        if self.items is None:
+            raise IndexError("ProjectItemListResponse is empty")
+        return self.items[index]
+
+    def __len__(self) -> int:
+        return len(self.items) if self.items else 0
+
+    def __iter__(self):
+        """Make ProjectItemListResponse iterable over its items."""
+        if self.items is None:
+            return iter([])
+        return iter(self.items)
+
+    def append(self, item: RequestItem) -> None:
+        """Append an Agent instance to the items list."""
+        if self.items is None:
+            self.items = []
+        self.items.append(item)
+
+
+class MembershipsResponse(BaseModel):
+    count: int
+    pages: int
+    organizations: list[OrganizationMembership]
+
+
+class ProjectMembershipsResponse(BaseModel):
+    count: int
+    pages: int
+    projects: list[ProjectMembership]
+
+
+class ProjectRolesResponse(BaseModel):
+    roles: list[Role]
+
+
+class ProjectMembersResponse(BaseModel):
+    members: list[Member]
+
+
+class OrganizationMembersResponse(BaseModel):
+    members: list[Member]
+
+
+class OrganizationListResponse(BaseModel):
+    count: int
+    pages: int
+    organizations: list[Organization]
+
+
+class OrganizationDataResponse(BaseModel):
+    organization: Organization

pygeai/proxy/clients.py

@@ -3,7 +3,9 @@ from typing import Optional, Dict, Any, List
 import uuid
 import requests
 from urllib3.exceptions import MaxRetryError
-from pygeai.proxy.tool import MCPTool
+from pygeai.proxy.tool import ProxiedTool
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
 
 
 @dataclass
@@ -21,7 +23,7 @@ class ToolProxyData:
     name: Optional[str] = None
     description: Optional[str] = None
     affinity: Optional[uuid.UUID] = None
-    tools: Optional[List[MCPTool]] = None
+    tools: Optional[List[ProxiedTool]] = None
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -150,7 +152,8 @@ class ProxyClient:
             response = self.session.request(method, url, **kwargs)
             response.raise_for_status()
             try:
-                return response.json()
+                validate_status_code(response)
+                return parse_json_response(response, "unknown operation")
             except ValueError:
                 return response.text
         except requests.exceptions.Timeout:

pygeai/proxy/config.py

@@ -1,7 +1,7 @@
 from pygeai.core.common.config import SettingsManager
 from typing import Optional
 import uuid
-
+import os
 
 class ProxySettingsManager(SettingsManager):
     """
@@ -100,6 +100,19 @@ class ProxySettingsManager(SettingsManager):
         """
         self.set_setting_value("PROXY_AFFINITY", str(affinity), alias)
 
+    def get_setting_value(self, setting_key: str, alias: str):
+        """
+        Get the value of a specific setting for a specific alias.
+
+        :param setting_key: str - Key of the setting to get
+        :param alias: str - Alias for the settings section. Defaults to DEFAULT_ALIAS.
+        """
+        env_var_name = setting_key.upper()
+        if os.getenv(env_var_name) and alias == self.DEFAULT_ALIAS:
+            return os.getenv(env_var_name)
+        else:
+            return super().get_setting_value(setting_key, alias)
+    
     def get_proxy_config(self, alias: str = DEFAULT_ALIAS) -> dict:
         """
         Get the complete proxy configuration for a specific alias.

pygeai/proxy/managers.py

@@ -6,10 +6,11 @@ import sys
 import requests
 from urllib3.exceptions import MaxRetryError
 import mcp.types as types
-from pygeai.proxy.servers import Server, MCPTool
+import a2a.types as a2a_types
+from pygeai.proxy.servers import MCPServer, ToolServer, ProxiedTool, A2AServer
 from pygeai.proxy.config import ProxySettingsManager
 from pygeai.proxy.clients import ProxyClient, ToolProxyData, ToolProxyJobResult
-
+from pygeai.core.utils.console import Console
 
 class ServerManager:
     """
@@ -28,8 +29,8 @@ class ServerManager:
         """
         self.servers_cfg = servers_cfg
         self.settings = settings
-        self.servers: Dict[str, Server] = {}
-        self.tools: Dict[str, MCPTool] = {}
+        self.servers: Dict[str, ToolServer] = {}
+        self.tools: Dict[str, ProxiedTool] = {}
         self.exit_stack: AsyncExitStack = AsyncExitStack()
 
     async def _initialize_servers(self) -> None:
@@ -40,23 +41,34 @@ class ServerManager:
         :raises: Exception - If server initialization fails
         """
         for server_cfg in self.servers_cfg:
-            sys.stdout.write(f"Initializing server {server_cfg['name']}\n")
-            server = Server(server_cfg['name'], server_cfg, self.settings)
+            Console.write_stdout(f"Initializing server {server_cfg['name']} type: {server_cfg['type']}")
+            if server_cfg['type'] == 'mcp':
+                server = MCPServer(server_cfg['name'], server_cfg, self.settings)
+            elif server_cfg['type'] == 'a2a':
+                server = A2AServer(server_cfg['name'], server_cfg, self.settings)
+            else:
+                raise ValueError(f"Invalid server type: {server_cfg['type']}")
             try:
                 await self.exit_stack.enter_async_context(server.exit_stack)
                 await server.initialize()
                 self.servers[server.name] = server
-                sys.stdout.write(f"Server {server.name} initialized successfully\n")        
+                Console.write_stdout(f"\nServer {server.name} initialized successfully", end="\n\n")        
             except Exception as e:
-                sys.stdout.write(f"Failed to initialize server {server.name}: {e}\n")
+                Console.write_exception(f"Failed to initialize server {server.name}:", e)
                 raise
 
         for server in self.servers.values():
-            sys.stdout.write(f"Listing tools for server {server.name}\n")
+            Console.write_stdout(f"Listing tools for server {server.name}", end="")
+            if server.public_prefix:
+                Console.write_stdout(f" | access scope:public prefix: {server.public_prefix}")
+            else:
+                Console.write_stdout(" ! access scope:private")
+
             tools = await server.list_tools()
             for tool in tools:
                 self.tools[tool.get_full_name()] = tool
-                sys.stdout.write(f"\tTool {tool.get_full_name()} added to server {server.name}\n")
+                Console.write_stdout(f"\tTool {tool.get_full_name()} added to server {server.name}")
+
     async def _initialize_client(self) -> ProxyClient:
         """
         Initialize the client.
@@ -68,17 +80,29 @@ class ServerManager:
         try:
             alias = self.settings.get_current_alias()
             client = ProxyClient(self.settings.get_api_key(alias), self.settings.get_base_url(alias), self.settings.get_proxy_id(alias))
-            sys.stdout.write(f"Registering proxy {self.settings.get_proxy_id(alias)} with name {self.settings.get_proxy_name(alias)} and description {self.settings.get_proxy_description(alias)} \n")
-            client.register(proxy_data=ToolProxyData(
+            Console.write_stdout(f"\nRegistering proxy {self.settings.get_proxy_id(alias)} with name {self.settings.get_proxy_name(alias)} and description {self.settings.get_proxy_description(alias)}")
+            result = client.register(proxy_data=ToolProxyData(
                 id=self.settings.get_proxy_id(alias),
                 name=self.settings.get_proxy_name(alias),
                 description=self.settings.get_proxy_description(alias),
                 affinity=self.settings.get_proxy_affinity(alias),
                 tools=list(self.tools.values())
             ))
-            sys.stdout.write(f"Proxy registered successfully\n")
+            Console.write_stdout("----------------------------------")
+            Console.write_stdout(f"Proxy registered successfully:")
+            if isinstance(result, dict) and isinstance(result.get("Messages"), list):
+                for message in result["Messages"]:
+                    description = message.get("Description", "")
+                    message_type = message.get("Type", None)
+
+                    if message_type == 1:
+                        Console.write_stderr(description)
+                    elif message_type == 2:
+                        Console.write_stdout(description)
+                Console.write_stdout("----------------------------------")
             return client
         except (ConnectionError, MaxRetryError):
+            Console.write_exception(f"Error registering proxy {self.settings.get_proxy_id(alias)}:")
             raise
     
     async def execute_tool(
@@ -126,7 +150,7 @@ class ServerManager:
             data = json.loads(raw_json)
             return data['function']['name'], data['function']['arguments']
         except (json.JSONDecodeError, KeyError) as e:
-            sys.stderr.write(f"Error extracting function call info: {e}\n")
+            Console.write_stdout(f"Error extracting function call info: {e}")
             return None, None
         
     async def start(self) -> None:
@@ -143,17 +167,16 @@ class ServerManager:
                 try:
                     client = await self._initialize_client()
                 except (ConnectionError, TimeoutError, RuntimeError) as e:
-                    sys.stdout.write(f"Error during client initialization: {e}\n")
+                    Console.write_exception(f"Error during client initialization:", e)
                     for i in range(15, 0, -1):
-                        sys.stdout.write(f"\rRetrying in {i} seconds...   ")
-                        sys.stdout.flush()
+                        Console.write_stdout(f"\rRetrying in {i} seconds...   ",'')
                         await asyncio.sleep(1)
-                    sys.stdout.write("\rRetrying now...           \n")
+                    Console.write_stdout("\rRetrying now...           ")
                     retry_count += 1
                     continue
 
                 retry_count = 0
-                sys.stdout.write(f"Waiting for jobs...\n")
+                Console.write_stdout(f"Waiting for jobs...")
                 while True:
                     try:
                         jobs = client.dequeue()
@@ -161,24 +184,24 @@ class ServerManager:
                     except requests.exceptions.RequestException as e:
                         retry_count += 1
                         if retry_count >= MAX_RETRIES:
-                            sys.stdout.write(f"Failed to dequeue jobs after {MAX_RETRIES} retries. \nException: {e}\nExiting...\n")
+                            Console.write_stderr(f"Failed to dequeue jobs after {MAX_RETRIES} retries.")
+                            Console.write_exception(f"Exception:", e, "\nExiting...")
                             return
-                        sys.stdout.write(f"Failed to dequeue jobs (attempt {retry_count}/{MAX_RETRIES}):\n")
+                        Console.write_stderr(f"Failed to dequeue jobs (attempt {retry_count}/{MAX_RETRIES}):")
                         for i in range(15, 0, -1):
-                            sys.stdout.write(f"\rRetrying in {i} seconds...   ")
-                            sys.stdout.flush()
+                            Console.write_stdout(f"\rRetrying in {i} seconds...   ",'')
                             await asyncio.sleep(1)
-                        sys.stdout.write("\rRetrying now...           \n")
+                        Console.write_stdout("\rRetrying now...           ")
                         continue
                     for job in jobs:
-                        sys.stdout.write(f"----------------------------------Job: {job.id}----------------------------------\n")
+                        Console.write_stdout(f"----------------------------------Job: {job.id}----------------------------------")
                         tool_name, arguments = self.extract_function_call_info(job.input)
                         if tool_name:
-                            sys.stdout.write(f"Executing tool {job.server}/{tool_name} with arguments {arguments}\n")
+                            Console.write_stdout(f"Executing tool {job.server}/{tool_name} with arguments {arguments}")
                             try:
                                 result = await self.execute_tool(job.server, tool_name, json.loads(arguments))
-                            except (RuntimeError, ConnectionError, TimeoutError) as e:
-                                sys.stdout.write(f"Error executing tool {tool_name}: {e}\n")
+                            except (Exception) as e:
+                                Console.write_exception(f"Error executing tool {tool_name}:", e)
                                 continue
 
                             if isinstance(result.content, list):
@@ -186,19 +209,24 @@ class ServerManager:
                                 for item in result.content:
                                     if isinstance(item, types.TextContent):
                                         text_parts.append(item.text)
+                                    elif isinstance(item, a2a_types.Part):
+                                        if isinstance(item.root, a2a_types.TextPart):
+                                            text_parts.append(item.root.text)
+                                        else:
+                                            Console.write_stdout(f"Unknown content type {type(item.root)}")
                                     else:
-                                        sys.stderr.write(f"Unknown content type {type(item)}\n")
+                                        Console.write_stdout(f"Unknown content type {type(item)}")
 
                             if text_parts:
                                 job.output = "\n".join(text_parts)
-                                sys.stdout.write(f"result: {job.output} success: {not result.isError}\n")
+                                Console.write_stdout(f"result: {job.output} success: {not result.isError}")
                                 try:
                                     client.send_result(ToolProxyJobResult(success=result.isError, job=job))
                                 except (ConnectionError, TimeoutError, RuntimeError) as e:
-                                    sys.stdout.write(f"Error sending result: {e}\n")
+                                    Console.write_exception("Error sending result:", e)
                             else:
-                                sys.stdout.write(f"{result}\n")
+                                Console.write_stdout(f"{result}")
                     await asyncio.sleep(1)
             finally:
-                sys.stdout.write("Proxy stopped\n")
+                Console.write_stdout("Proxy stopped")
                 await self.exit_stack.aclose()

pygeai/proxy/servers.py

@@ -1,27 +1,34 @@
 """Server module for managing MCP server connections and tool execution."""
-
 import asyncio
 import os
 import shutil
-import sys
+import httpx
+from types import SimpleNamespace
+from uuid import uuid4
 from contextlib import AsyncExitStack
+from abc import ABC, abstractmethod
 from typing import Any, Dict
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 from mcp.client.sse import sse_client
-from pygeai.proxy.tool import MCPTool
+from pygeai.proxy.tool import ProxiedTool
 from pygeai.proxy.config import ProxySettingsManager
+from a2a.client import A2AClient, A2ACardResolver
+from a2a.types import (
+    AgentCard, SendMessageRequest, MessageSendParams,
+    Message, Task, SendMessageSuccessResponse
+)
 
+from pygeai.core.utils.console import Console
 
-class Server:
+class ToolServer(ABC):
     """
-    Manages MCP server connections and tool execution.
+    Interface for tool servers like MCP and A2A.
 
-    :param sever_name: str - Name of the server
-    :param config: Dict[str, Any] - Server configuration
-    :param settings: ProxySettingsManager - Proxy settings manager
+    Subclasses must implement methods to initialize the server,
+    list available tools, and execute a tool.
     """
-
+   
     def __init__(self, sever_name: str, config: Dict[str, Any], settings: ProxySettingsManager):
         """
         Initialize the server.
@@ -33,11 +40,10 @@ class Server:
         self.config = config
         self.settings = settings
         self.name: str = sever_name
-        self.stdio_context: Any | None = None
-        self.session: ClientSession | None = None
+        self.public_prefix: str | None = None
         self.exit_stack: AsyncExitStack = AsyncExitStack()
-        self.publicpreffix: str | None = None
 
+    @abstractmethod
     async def initialize(self) -> None:
         """
         Initialize the server connection.
@@ -47,8 +53,155 @@ class Server:
         :raises: RuntimeError - If server initialization fails
         :raises: ConnectionError - If connection to server fails
         """
-        self.publicpreffix = self.config.get("publicpreffix")
-        transport = self.config.get("transport") or ("sse" if "uri" in self.config else "stdio")
+        pass
+
+    @abstractmethod
+    async def list_tools(self) -> list[ProxiedTool]:
+        """
+        List available tools from the server.
+
+        :return: list[Tool] - List of available tools
+        :raises: RuntimeError - If server is not initialized
+        """
+        pass
+
+    @abstractmethod
+    async def execute_tool(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any],
+        retries: int = 2,
+        delay: float = 1.0,
+    ) -> Any:
+        """
+        Execute a tool with retry mechanism.
+
+        :param tool_name: str - Name of the tool to execute
+        :param arguments: dict[str, Any] - Tool arguments
+        :param retries: int - Number of retry attempts
+        :param delay: float - Delay between retries in seconds
+        :return: Any - Tool execution result
+        :raises: RuntimeError - If server is not initialized
+        :raises: ConnectionError - If connection to server fails
+        :raises: ValueError - If tool execution fails
+        """
+        pass
+
+class A2AServer(ToolServer):
+    """
+    Manages A2A server connections and tool execution.
+    """
+    def __init__(self, sever_name: str, config: Dict[str, Any], settings: ProxySettingsManager):
+        super().__init__(sever_name, config, settings)
+        self.client: A2AClient | None = None
+        self.card_url: str = self.config["url"]
+        self.agent_card: AgentCard | None = None
+        self.httpx_client: httpx.AsyncClient | None = None
+
+    async def initialize(self) -> None:
+        """
+        Initialize the A2A client from the agent card and convert agent skills into tools
+        compatible with OpenAI function call format.
+        """
+        try:
+            self.httpx_client = httpx.AsyncClient(timeout=60.0)
+            self.public_prefix = self.config.get("public_prefix")
+            headers = self.config.get("headers")
+            if headers:
+                self.httpx_client.headers.update(headers)
+            resolver = A2ACardResolver(httpx_client=self.httpx_client, base_url=self.card_url)
+            self.agent_card = await resolver.get_agent_card()
+            self.client = A2AClient(httpx_client=self.httpx_client, agent_card=self.agent_card)
+
+        except httpx.HTTPError as e:
+            Console.write_exception(f"HTTP error initializing A2A server {self.name}:", e)
+            raise ConnectionError(f"Failed to connect to A2A server: {e}") from e
+        except ValueError as e:
+            Console.write_exception(f"Invalid configuration for A2A server {self.name}:" ,e)
+            raise ValueError(f"Invalid A2A server configuration: {e}") from e
+        except RuntimeError as e:
+            Console.write_exception(f"Runtime error initializing A2A server {self.name}:", e)
+            raise RuntimeError(f"A2A server initialization failed: {e}") from e
+        
+    async def list_tools(self) -> list[ProxiedTool]:
+        if not self.client:
+            raise RuntimeError(f"Server {self.name} not initialized")
+        input_schema = {
+            "type": "object",
+            "properties": {
+                "input-text": {
+                    "type": "string",
+                    "description": "The input text to send to the agent for execution."
+                }
+            },
+            "required": ["input-text"]
+        }
+        tools = []
+        for skill in self.agent_card.skills:
+            tools.append(ProxiedTool(self.name, skill.id, skill.description, self.public_prefix, input_schema))
+        return tools
+
+    async def execute_tool(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any],
+        retries: int = 2,
+        delay: float = 1.0,
+    ) -> Any:
+        Console.write_stdout(f"Executing {tool_name}...")
+        message_id = uuid4().hex
+        send_message_payload: dict[str, Any] = {
+            'message': {
+                'role': 'user',
+                'parts': [
+                    {
+                        'kind': 'text',
+                        'text': (
+                            'Use your skill:' + tool_name +
+                            ' with this input:' + arguments["input-text"]
+                        )
+                    }
+                ],
+                'messageId': message_id,
+            },
+        }
+        request = SendMessageRequest(
+            id=message_id,
+            params=MessageSendParams(**send_message_payload)
+        )
+
+        response = await self.client.send_message(request)
+        result = []
+        if isinstance(response.root, SendMessageSuccessResponse):
+            if isinstance(response.root.result, Message):
+                result = response.root.result.parts
+            elif isinstance(response.root, Task):
+                Console.write_stderr(f"Task response: {response.root.result}")
+            else:
+                Console.write_stderr(f"Unknown response type: {type(response.root)}")
+                raise ValueError(f"Unknown response type: {type(response.root)}")
+        
+        return SimpleNamespace(content=result, isError=False)
+
+class MCPServer(ToolServer):
+    """
+    Manages MCP server connections and tool execution.
+
+    :param sever_name: str - Name of the server
+    :param config: Dict[str, Any] - Server configuration
+    :param settings: ProxySettingsManager - Proxy settings manager
+    """
+    def __init__(self, sever_name: str, config: Dict[str, Any], settings: ProxySettingsManager):
+        super().__init__(sever_name, config, settings)
+        self.public_prefix = config.get("public_prefix")
+        self.stdio_context: Any | None = None
+        self.session: ClientSession | None = None
+
+    async def initialize(self) -> None:
+        self.public_prefix = self.config.get("public_prefix")
+        transport = self.config.get("transport") or (
+            "sse" if ("uri" in self.config  or "url" in self.config) else "stdio"
+        )
         try:
             if transport == "stdio":
                 command = (
@@ -62,9 +215,11 @@ class Server:
                 server_params = StdioServerParameters(
                     command=command,
                     args=self.config["args"],
-                    env={**os.environ, **self.config["env"]}
-                    if self.config.get("env")
-                    else None,
+                    env=(
+                        {**os.environ, **self.config["env"]}
+                        if self.config.get("env")
+                        else None
+                    ),
                 )
             
                 stdio_transport = await self.exit_stack.enter_async_context(
@@ -72,17 +227,19 @@ class Server:
                 )
                 read, write = stdio_transport
             elif transport == "sse":
-                uri = self.config.get("uri")
+                uri = self.config.get("uri", self.config["url"])
                 if not uri:
                     raise ValueError("Missing 'uri' for sse transport")
-
-                sse_transport = await self.exit_stack.enter_async_context(
-                    sse_client(
-                        url=self.config["uri"],
-                        headers=self.config.get("headers")
+                try:
+                    sse_transport = await self.exit_stack.enter_async_context(
+                        sse_client(
+                            url=uri,
+                            headers=self.config.get("headers")
+                        )
                     )
-                )
-                read, write = sse_transport
+                    read, write = sse_transport
+                except httpx.HTTPStatusError as e:
+                    Console.write_exception(f"HTTP error initializing MCP server {self.name}:", e)
             else:
                 raise ValueError(f"Unsupported transport: {transport}")
             
@@ -92,16 +249,10 @@ class Server:
             await session.initialize()
             self.session = session
         except (RuntimeError, ConnectionError, ValueError) as e:
-            sys.stderr.write(f"Error initializing server {self.name}: {e}\n")
+            Console.write_exception(f"Error initializing server {self.name}:", e)
             raise
 
-    async def list_tools(self) -> list[MCPTool]:
-        """
-        List available tools from the server.
-
-        :return: list[Tool] - List of available tools
-        :raises: RuntimeError - If server is not initialized
-        """
+    async def list_tools(self) -> list[ProxiedTool]:
         if not self.session:
             raise RuntimeError(f"Server {self.name} not initialized")
 
@@ -112,7 +263,13 @@ class Server:
             if isinstance(item, tuple) and item[0] == "tools":
                 for tool in item[1]:
                     tools.append(
-                        MCPTool(self.name, tool.name, tool.description, self.publicpreffix, tool.inputSchema)
+                        ProxiedTool(
+                            self.name,
+                            tool.name,
+                            tool.description,
+                            self.public_prefix,
+                            tool.inputSchema
+                        )
                     )
 
         return tools
@@ -124,36 +281,24 @@ class Server:
         retries: int = 2,
         delay: float = 1.0,
     ) -> Any:
-        """
-        Execute a tool with retry mechanism.
-
-        :param tool_name: str - Name of the tool to execute
-        :param arguments: dict[str, Any] - Tool arguments
-        :param retries: int - Number of retry attempts
-        :param delay: float - Delay between retries in seconds
-        :return: Any - Tool execution result
-        :raises: RuntimeError - If server is not initialized
-        :raises: ConnectionError - If connection to server fails
-        :raises: ValueError - If tool execution fails
-        """
         if not self.session:
             raise RuntimeError(f"Server {self.name} not initialized")
 
         attempt = 0
         while attempt < retries:
             try:
-                sys.stdout.write(f"Executing {tool_name}...\n")
+                Console.write_stdout(f"Executing {tool_name}...")
                 result = await self.session.call_tool(tool_name, arguments)
                 return result
 
             except (RuntimeError, ConnectionError, ValueError) as e:
                 attempt += 1
-                sys.stderr.write(
-                    f"Error executing tool: {e}. Attempt {attempt} of {retries}.\n"
+                Console.write_exception(
+                    "Error executing tool:", e, f". Attempt {attempt} of {retries}.\n"
                 )
                 if attempt < retries:
-                    sys.stderr.write(f"Retrying in {delay} seconds...\n")
+                    Console.write_stdout(f"Retrying in {delay} seconds...")
                     await asyncio.sleep(delay)
                 else:
-                    sys.stderr.write("Max retries reached. Failing.\n")
+                    Console.write_stdout("Max retries reached. Failing.")
                     raise