Merge pull request #30 from kayba-ai/revert-27-no-opik-warning

Revert "fix: eliminate Opik integration warnings for base installs"

Author: Lanzelot1

ace/llm_providers/litellm_client.py

@@ -240,13 +240,6 @@ def _setup_router(self) -> None:
 
     def _setup_opik_integration(self) -> None:
         """Set up Opik integration for automatic token and cost tracking."""
-        # Check if explicitly disabled
-        if os.environ.get("OPIK_DISABLED", "").lower() in ("true", "1", "yes"):
-            logger.debug(
-                "Opik integration disabled via OPIK_DISABLED environment variable"
-            )
-            return
-
         try:
             # Import observability module
             from ..observability import get_integration

ace/observability/opik_integration.py

@@ -8,7 +8,6 @@
 from __future__ import annotations
 
 import logging
-import os
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Union
 from dataclasses import asdict
@@ -49,11 +48,6 @@ def decorator(func):
 logger = logging.getLogger(__name__)
 
 
-def _should_skip_opik() -> bool:
-    """Check if Opik should be disabled via environment variable."""
-    return os.environ.get("OPIK_DISABLED", "").lower() in ("true", "1", "yes")
-
-
 class OpikIntegration:
     """
     Main integration class for ACE + Opik observability.
@@ -86,12 +80,10 @@ def __init__(
                 opik.configure(use_local=True)
                 logger.info(f"Opik configured locally for project: {project_name}")
             except Exception as e:
-                logger.debug(f"Opik configuration skipped: {e}")
+                logger.warning(f"Failed to configure Opik: {e}")
                 self.enabled = False
         elif not OPIK_AVAILABLE:
-            logger.debug(
-                "Opik not available. Install with: pip install ace-framework[observability]"
-            )
+            logger.warning("Opik not available. Install with: pip install opik")
 
     def log_bullet_evolution(
         self,
@@ -343,12 +335,7 @@ def get_integration() -> OpikIntegration:
     """Get or create global Opik integration instance."""
     global _global_integration
     if _global_integration is None:
-        if _should_skip_opik():
-            # Return disabled integration
-            _global_integration = OpikIntegration(enable_auto_config=False)
-            _global_integration.enabled = False
-        else:
-            _global_integration = OpikIntegration()
+        _global_integration = OpikIntegration()
     return _global_integration
 
 

examples/LMstudio/lmstudio_starter_template.py

@@ -23,15 +23,12 @@ def check_lm_studio_running():
         response = requests.get("http://localhost:1234/v1/models", timeout=5)
         if response.status_code == 200:
             models = response.json()
-            if models.get("data"):
-                return True, models["data"][0]["id"]  # Return first available model
+            if models.get('data'):
+                return True, models['data'][0]['id']  # Return first available model
             return False, "No models loaded in LM Studio"
         return False, f"LM Studio responded with status {response.status_code}"
     except requests.ConnectionError:
-        return (
-            False,
-            "Cannot connect to LM Studio. Make sure it's running on port 1234.",
-        )
+        return False, "Cannot connect to LM Studio. Make sure it's running on port 1234."
     except Exception as e:
         return False, f"Error checking LM Studio: {e}"
 
@@ -57,15 +54,14 @@ def main():
 
     # LM Studio configuration for LiteLLM
     import os
-
     os.environ["LM_STUDIO_API_BASE"] = "http://localhost:1234/v1"
 
     agent = ACELiteLLM(
         model="lm_studio/qwen3-vl-8b",
         max_tokens=1024,
         temperature=0.2,
         is_learning=True,
-        playbook_path=str(playbook_path) if playbook_path.exists() else None,
+        playbook_path=str(playbook_path) if playbook_path.exists() else None
     )
 
     # 2. Try asking questions before learning
@@ -110,7 +106,7 @@ def main():
         "What is 3+3?",
         "What color is grass?",
         "What is the capital of Italy?",
-        "Which planet is closest to the Sun?",
+        "Which planet is closest to the Sun?"
     ]
 
     for question in test_questions:
@@ -129,11 +125,7 @@ def main():
             helpful = bullet.helpful
             harmful = bullet.harmful
             score = f"(+{helpful}/-{harmful})"
-            content_preview = (
-                bullet.content[:80] + "..."
-                if len(bullet.content) > 80
-                else bullet.content
-            )
+            content_preview = bullet.content[:80] + "..." if len(bullet.content) > 80 else bullet.content
             print(f"  {i}. {content_preview} {score}")
 
     # 7. Save learned knowledge for future use
@@ -148,4 +140,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

examples/browser-use/TEMPLATE.py

@@ -20,7 +20,10 @@ async def main():
     """Minimal ACE browser automation example."""
 
     # Create ACE agent
-    agent = ACEAgent(llm=ChatBrowserUse(), ace_model="gpt-4o-mini")
+    agent = ACEAgent(
+        llm=ChatBrowserUse(),
+        ace_model="gpt-4o-mini"
+    )
 
     # Define your tasks
     tasks = [
@@ -44,4 +47,4 @@ async def main():
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

examples/browser-use/domain-checker/ace_domain_checker.py

@@ -32,13 +32,11 @@
 from ace.observability import configure_opik
 from browser_use import ChatBrowserUse
 
-
 # Utility function for timeout calculation
 def calculate_timeout_steps(timeout_seconds: float) -> int:
     """Calculate steps for timeout based on 1 step per 12 seconds."""
     return int(timeout_seconds // 12)
 
-
 # Import domain-specific utilities
 from domain_utils import get_test_domains
 
@@ -68,9 +66,7 @@ def calculate_timeout_steps(timeout_seconds: float) -> int:
 """
 
 
-def get_ace_token_usage(
-    run_start_time: datetime.datetime = None,
-) -> tuple[int, int, int, int]:
+def get_ace_token_usage(run_start_time: datetime.datetime = None) -> tuple[int, int, int, int]:
     """Query Opik for ACE token usage only.
 
     Returns:
@@ -112,7 +108,9 @@ def get_ace_token_usage(
                     filter_string=f'start_time >= "{recent_time}"',
                     max_results=50,
                 )
-                print(f"   📊 Found {len(traces)} recent traces in '{project}' project")
+                print(
+                    f"   📊 Found {len(traces)} recent traces in '{project}' project"
+                )
                 all_traces.extend(traces)
             except Exception as e:
                 print(f"   ⚠️ Failed to search '{project}' project: {e}")
@@ -196,32 +194,21 @@ def parse_domain_result(output: str, domain: str) -> dict:
         return {"status": "TAKEN"}
 
     # Check for natural language indicators of availability
-    elif (
-        ("AVAILABLE" in output_upper and domain_upper in output_upper)
-        or ("ADD TO CART" in output_upper and domain_upper in output_upper)
-        or ("PRICE:" in output_upper and domain_upper in output_upper)
-        or (
-            "REGISTRATION" in output_upper
-            and "AVAILABLE" in output_upper
-            and domain_upper in output_upper
-        )
-    ):
+    elif ("AVAILABLE" in output_upper and domain_upper in output_upper) or \
+         ("ADD TO CART" in output_upper and domain_upper in output_upper) or \
+         ("PRICE:" in output_upper and domain_upper in output_upper) or \
+         ("REGISTRATION" in output_upper and "AVAILABLE" in output_upper and domain_upper in output_upper):
         return {"status": "AVAILABLE"}
 
     # Check for natural language indicators of taken/unavailable
-    elif (
-        ("TAKEN" in output_upper and domain_upper in output_upper)
-        or ("REGISTERED" in output_upper and domain_upper in output_upper)
-        or ("NOT AVAILABLE" in output_upper and domain_upper in output_upper)
-        or ("UNAVAILABLE" in output_upper and domain_upper in output_upper)
-    ):
+    elif ("TAKEN" in output_upper and domain_upper in output_upper) or \
+         ("REGISTERED" in output_upper and domain_upper in output_upper) or \
+         ("NOT AVAILABLE" in output_upper and domain_upper in output_upper) or \
+         ("UNAVAILABLE" in output_upper and domain_upper in output_upper):
         return {"status": "TAKEN"}
 
     else:
-        return {
-            "status": "ERROR",
-            "reason": f"Could not parse result: {output[:100]}...",
-        }
+        return {"status": "ERROR", "reason": f"Could not parse result: {output[:100]}..."}
 
 
 async def check_single_domain(agent: ACEAgent, domain: str) -> dict:
@@ -236,6 +223,7 @@ async def check_single_domain(agent: ACEAgent, domain: str) -> dict:
     # Track browser-use tokens across all attempts
     total_browseruse_tokens = 0
 
+
     for attempt in range(max_retries):
         print(f"   🔄 Attempt {attempt + 1}/{max_retries}")
 
@@ -245,7 +233,8 @@ async def check_single_domain(agent: ACEAgent, domain: str) -> dict:
 
             # Run domain check with ACE learning (with timeout like baseline)
             history = await asyncio.wait_for(
-                agent.run(task=task, max_steps=25), timeout=180.0
+                agent.run(task=task, max_steps=25),
+                timeout=180.0
             )
 
             # Extract results
@@ -302,12 +291,10 @@ async def check_single_domain(agent: ACEAgent, domain: str) -> dict:
                         print(f"   ⚠️ Could not get tokens from history: {e}")
 
                 # Method 2: Try agent internal token tracking (ACEAgent specific)
-                if attempt_tokens == 0 and hasattr(agent, "browser_llm"):
+                if attempt_tokens == 0 and hasattr(agent, 'browser_llm'):
                     try:
                         # ACEAgent uses browser_use Agent internally, check if it has token tracking
-                        if hasattr(agent, "_last_agent") and hasattr(
-                            agent._last_agent, "token_cost_service"
-                        ):
+                        if hasattr(agent, '_last_agent') and hasattr(agent._last_agent, 'token_cost_service'):
                             usage_summary = (
                                 await agent._last_agent.token_cost_service.get_usage_summary()
                             )
@@ -367,13 +354,9 @@ async def check_single_domain(agent: ACEAgent, domain: str) -> dict:
 
             steps = actual_steps + timeout_steps
             total_steps += steps
-            attempt_details.append(
-                f"attempt {attempt + 1}: {steps} steps (timeout, +{timeout_steps} for duration)"
-            )
+            attempt_details.append(f"attempt {attempt + 1}: {steps} steps (timeout, +{timeout_steps} for duration)")
             last_error = f"Timeout on attempt {attempt + 1}"
-            print(
-                f"   ⏰ Timeout after {actual_steps} steps (+{timeout_steps} timeout penalty)"
-            )
+            print(f"   ⏰ Timeout after {actual_steps} steps (+{timeout_steps} timeout penalty)")
 
         except Exception as e:
             # Get actual steps even on error
@@ -426,12 +409,10 @@ async def check_single_domain(agent: ACEAgent, domain: str) -> dict:
                     print(f"   ⚠️ Could not get tokens from history: {e}")
 
             # Method 2: Try agent internal token tracking (ACEAgent specific)
-            if attempt_tokens == 0 and hasattr(agent, "browser_llm"):
+            if attempt_tokens == 0 and hasattr(agent, 'browser_llm'):
                 try:
                     # ACEAgent uses browser_use Agent internally, check if it has token tracking
-                    if hasattr(agent, "_last_agent") and hasattr(
-                        agent._last_agent, "token_cost_service"
-                    ):
+                    if hasattr(agent, '_last_agent') and hasattr(agent._last_agent, 'token_cost_service'):
                         usage_summary = (
                             await agent._last_agent.token_cost_service.get_usage_summary()
                         )
@@ -451,6 +432,7 @@ async def check_single_domain(agent: ACEAgent, domain: str) -> dict:
                 f"   🤖 Attempt {attempt + 1} tokens: {attempt_tokens} (total: {total_browseruse_tokens})"
             )
 
+
     # All retries failed - use accumulated tokens from all attempts
     print(f"   ❌ All {max_retries} attempts failed")
     return {
@@ -459,7 +441,7 @@ async def check_single_domain(agent: ACEAgent, domain: str) -> dict:
         "success": False,
         "correct": False,
         "expected": "AVAILABLE",
-        "steps": steps if "steps" in locals() else 0,
+        "steps": steps if 'steps' in locals() else 0,
         "total_steps": total_steps,
         "error": f"Failed after {max_retries} attempts. Last error: {last_error}",
         "attempt": max_retries,
@@ -490,12 +472,12 @@ async def main():
 
     # Create ACE agent - handles everything automatically!
     agent = ACEAgent(
-        llm=ChatBrowserUse(),  # Browser automation LLM
-        ace_model="claude-haiku-4-5-20251001",  # ACE learning LLM
-        ace_max_tokens=4096,  # Enough for domain check analysis
+        llm=ChatBrowserUse(),                    # Browser automation LLM
+        ace_model="claude-haiku-4-5-20251001",   # ACE learning LLM
+        ace_max_tokens=4096,                     # Enough for domain check analysis
         playbook_path=str(playbook_path) if playbook_path.exists() else None,
-        max_steps=25,  # Browser automation steps
-        calculate_cost=True,  # Track usage
+        max_steps=25,                            # Browser automation steps
+        calculate_cost=True                      # Track usage
     )
 
     # Show current knowledge
@@ -562,9 +544,7 @@ async def main():
     print(f"\n{'='*60}")
     print("📊 DOMAIN CHECK RESULTS")
     print("=" * 60)
-    print(
-        f"{'#':<3} {'Domain':<25} {'Status':<10} {'Acc':<4} {'Steps':<8} {'Browser-Tokens':<13} {'Details'}"
-    )
+    print(f"{'#':<3} {'Domain':<25} {'Status':<10} {'Acc':<4} {'Steps':<8} {'Browser-Tokens':<13} {'Details'}")
     print("-" * 93)
 
     total_steps = 0
@@ -593,9 +573,7 @@ async def main():
         accuracy_indicator = "✓" if correct else "✗"
         browseruse_tokens = result.get("browseruse_tokens", 0)
 
-        print(
-            f"{i:<3} {result['domain']:<25} {result['status']:<10} {accuracy_indicator:<4} {total_steps_domain:<8} {browseruse_tokens:<12} {step_details}"
-        )
+        print(f"{i:<3} {result['domain']:<25} {result['status']:<10} {accuracy_indicator:<4} {total_steps_domain:<8} {browseruse_tokens:<12} {step_details}")
 
         if not correct and result["success"]:
             expected = result.get("expected", "UNKNOWN")
@@ -652,9 +630,7 @@ async def main():
         for i, bullet in enumerate(recent_strategies, 1):
             helpful = bullet.helpful
             harmful = bullet.harmful
-            effectiveness = (
-                "✅" if helpful > harmful else "⚠️" if helpful == harmful else "❌"
-            )
+            effectiveness = "✅" if helpful > harmful else "⚠️" if helpful == harmful else "❌"
             print(f"{i}. {effectiveness} {bullet.content}")
             print(f"   (+{helpful}/-{harmful})")
 
@@ -670,4 +646,4 @@ async def main():
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

examples/browser-use/domain-checker/baseline_domain_checker.py

@@ -18,13 +18,11 @@
 # Import common utilities from parent directory
 import sys
 
-
 # Utility function for timeout calculation
 def calculate_timeout_steps(timeout_seconds: float) -> int:
     """Calculate steps for timeout based on 1 step per 12 seconds."""
     return int(timeout_seconds // 12)
 
-
 # Import domain-specific utilities from local module
 from domain_utils import (
     get_test_domains,
@@ -71,6 +69,7 @@ async def check_domain(domain: str, headless: bool = True):
             # Run with timeout
             history = await asyncio.wait_for(agent.run(), timeout=180.0)
 
+
             # Parse result (back to original working logic)
             output = history.final_result() if hasattr(history, "final_result") else ""
             steps = (