fix: resolve circular import with lazy initialization of tracing processor

The circular import was caused by immediate instantiation of
AgentexTracingProcessorConfig at module load time, which triggered:
tracer.py → tracing_processor_manager → agentex_tracing_processor
→ adk.utils.client → adk.utils → adk.providers → tracer.py

Solution: Implement lazy initialization using the double-checked locking
pattern. The default Agentex tracing processor is now initialized on first
use (when get_sync_processors() or get_async_processors() is called) rather
than at module load time.

This breaks the circular dependency while maintaining the same functionality
and avoiding any need for commented-out code or workarounds.

Tests: Verified with test_function_tool.py - all 10 tests pass

Author: prassanna-ravishankar

src/agentex/lib/core/tracing/tracing_processor_manager.py

@@ -1,18 +1,18 @@
 from threading import Lock
 
-from agentex.lib.core.tracing.processors.agentex_tracing_processor import (
-    AgentexAsyncTracingProcessor,
-    AgentexSyncTracingProcessor,
-)
+from agentex.lib.types.tracing import TracingProcessorConfig, AgentexTracingProcessorConfig
 from agentex.lib.core.tracing.processors.sgp_tracing_processor import (
-    SGPAsyncTracingProcessor,
     SGPSyncTracingProcessor,
+    SGPAsyncTracingProcessor,
+)
+from agentex.lib.core.tracing.processors.agentex_tracing_processor import (
+    AgentexSyncTracingProcessor,
+    AgentexAsyncTracingProcessor,
 )
 from agentex.lib.core.tracing.processors.tracing_processor_interface import (
-    AsyncTracingProcessor,
     SyncTracingProcessor,
+    AsyncTracingProcessor,
 )
-from agentex.lib.types.tracing import AgentexTracingProcessorConfig, TracingProcessorConfig
 
 
 class TracingProcessorManager:
@@ -30,6 +30,7 @@ def __init__(self):
         self.sync_processors: list[SyncTracingProcessor] = []
         self.async_processors: list[AsyncTracingProcessor] = []
         self.lock = Lock()
+        self._initialized = False
 
     def add_processor_config(self, processor_config: TracingProcessorConfig) -> None:
         with self.lock:
@@ -43,10 +44,20 @@ def set_processor_configs(self, processor_configs: list[TracingProcessorConfig])
             for processor_config in processor_configs:
                 self.add_processor_config(processor_config)
 
+    def _ensure_initialized(self):
+        """Lazily initialize the default Agentex processor on first use to avoid circular imports."""
+        if not self._initialized:
+            with self.lock:
+                if not self._initialized:  # Double-check inside lock
+                    self.add_processor_config(AgentexTracingProcessorConfig())
+                    self._initialized = True
+
     def get_sync_processors(self) -> list[SyncTracingProcessor]:
+        self._ensure_initialized()
         return self.sync_processors
 
     def get_async_processors(self) -> list[AsyncTracingProcessor]:
+        self._ensure_initialized()
         return self.async_processors
 
 
@@ -58,5 +69,5 @@ def get_async_processors(self) -> list[AsyncTracingProcessor]:
 get_sync_tracing_processors = GLOBAL_TRACING_PROCESSOR_MANAGER.get_sync_processors
 get_async_tracing_processors = GLOBAL_TRACING_PROCESSOR_MANAGER.get_async_processors
 
-# Add the Agentex tracing processor by default
-add_tracing_processor_config(AgentexTracingProcessorConfig())
+# Note: The default Agentex tracing processor is initialized lazily on first use
+# to avoid circular import issues. See _ensure_initialized() method.