v1

src/proxy_lite/logger.py

@@ -1,5 +1,7 @@
+import asyncio
 import logging
 import sys
+import time  # Added for time.sleep
 from typing import Literal
 from uuid import uuid4
 
@@ -7,6 +9,29 @@ from rich.logging import RichHandler
 
 
 class StructuredLogger(logging.Logger):
+    def _stream_message_sync(self, message: str) -> None:
+        """Synchronous version of stream message to run in separate thread."""
+        try:
+            sys.stdout.write("\r")  # Overwrite current line
+            for char in message:
+                sys.stdout.write(char)
+                sys.stdout.flush()
+                time.sleep(0.002)  # Using regular sleep in thread
+            sys.stdout.write("\n")
+        except Exception:
+            pass
+
+    async def stream_message(self, message: str) -> None:
+        """Streams the message character by character in a separate thread."""
+        return await asyncio.to_thread(self._stream_message_sync, message)
+
+    # def info_stream(self, msg: str) -> Coroutine[Any, Any, None]:
+    #     """Special method for streaming messages that returns a coroutine."""
+    #     # Log the message normally first
+    #     # self.info(msg)
+    #     # Return the streaming coroutine
+    #     return self.stream_message(msg)
+
     def _log(
         self,
         level,
@@ -31,6 +56,7 @@ class StructuredLogger(logging.Logger):
             json_fields["exception_message"] = str(exc_value)
 
         json_fields.update(extra)
+
         super()._log(
             level,
             msg,
@@ -50,32 +76,31 @@ def create_logger(
     unique_name = f"{name}-{str(uuid4())[:8]}"
     logger = logging.getLogger(unique_name)
     logger.setLevel(level)
-    handler = RichHandler(
+
+    # Standard RichHandler for structured logs
+    rich_handler = RichHandler(
         rich_tracebacks=True,
         markup=True,
         show_path=False,
         show_time=False,
         log_time_format="[%s]",
     )
+
     if detailed_name:
-        handler.setFormatter(logging.Formatter("%(name)s:\n%(message)s\n------"))
+        rich_handler.setFormatter(logging.Formatter("%(name)s:\n%(message)s"))
     else:
-        handler.setFormatter(logging.Formatter("%(message)s\n------"))
-    logger.addHandler(handler)
+        rich_handler.setFormatter(logging.Formatter("-----\n%(message)s"))
+
+    logger.addHandler(rich_handler)
     logger.propagate = False
+
     return logger
 
 
 # Set StructuredLogger as the default logger class
 logging.setLoggerClass(StructuredLogger)
 
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
-logger.propagate = True
-handler = RichHandler(
-    rich_tracebacks=True,
-    markup=True,
-    show_path=False,
-    show_time=False,
-)
-logger.addHandler(handler)
+# Initialize logger
+logger = create_logger(__name__, level="INFO")
+
+stream_logger = create_logger(__name__, level="INFO", detailed_name=False)

src/proxy_lite/solvers/simple_solver.py

@@ -2,7 +2,7 @@
 import json
 import re
 from functools import cached_property
-from typing import Literal, Optional
+from typing import Any, Coroutine, Literal, Optional
 
 from proxy_lite.agents import AgentConfigTypes, Agents, BaseAgent
 from proxy_lite.environments.environment_base import Action, Observation
@@ -27,6 +27,7 @@ class SimpleSolverConfig(BaseSolverConfig):
 class SimpleSolver(BaseSolver):
     task: Optional[str] = None
     complete: bool = False
+    coroutines: list[Coroutine[Any, Any, None]] = []
 
     @cached_property
     def tools(self) -> list[Tool]:
@@ -81,13 +82,17 @@ class SimpleSolver(BaseSolver):
         observation_match = re.search(r"<observation>(.*?)</observation>", text_content, re.DOTALL)
         observation_content = observation_match.group(1).strip() if observation_match else ""
 
-        self.logger.info(f"🌐 [bold blue]Observation:[/] {observation_content}")
+        self.logger.info("🌐 [bold blue]Observation:[/]")
+        # await self.logger.stream_message(observation_content)
+        self.logger._stream_message_sync(observation_content)
 
         # Extract text between thinking tags if present
         thinking_match = re.search(r"<thinking>(.*?)</thinking>", text_content, re.DOTALL)
         thinking_content = thinking_match.group(1).strip() if thinking_match else text_content
 
-        self.logger.info(f"🤖 [bold purple]Action:[/] {thinking_content}")
+        self.logger.info("🧠 [bold purple]Thinking:[/]")
+        # await self.logger.stream_message(thinking_content)
+        self.logger._stream_message_sync(thinking_content)
 
         return Action(tool_calls=message.tool_calls, text=text_content)