connectonion 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

connectonion/cli/browser_agent/scroll_strategies.py

@@ -0,0 +1,276 @@
+"""
+Purpose: Universal scrolling strategies with AI-powered selection and screenshot-based verification
+LLM-Note:
+  Dependencies: imports from [typing, pydantic, connectonion.llm_do, PIL.Image, os, time] | imported by [web_automation.py] | tested by [tests/test_final_scroll.py]
+  Data flow: receives page: Page, take_screenshot: Callable, times: int, description: str from web_automation.scroll() → scroll_with_verification() orchestrates 3 strategies → ai_scroll_strategy() calls llm_do(HTML+scrollable_elements→ScrollStrategy, gpt-4o) → element_scroll_strategy()/page_scroll_strategy() fallbacks → page.evaluate(javascript) executes scroll → screenshots_are_different() compares PIL Images with 1% pixel threshold → returns success/failure string
+  State/Effects: calls page.evaluate() multiple times (mutates DOM scroll positions) | take_screenshot() writes PNG files to screenshots/*.png | time.sleep(1-1.2) between scroll iterations | AI calls to gpt-4o with temperature=0.1 for strategy generation
+  Integration: exposes scroll_with_verification() as main entry point from WebAutomation.scroll() | exposes scroll_page(), scroll_element() as standalone utilities | ScrollStrategy Pydantic model defines AI output schema (javascript: str, explanation: str) | screenshots_are_different() uses PIL for pixel-level comparison
+  Performance: ai_scroll_strategy() calls llm_do() once per scroll session (100-500ms) | analyzes first 5000 chars of HTML | finds up to 3 scrollable elements | executes JS times iterations with 1.2s delays | element/page strategies are synchronous JS execution (fast) | PIL screenshot comparison ~50-100ms
+  Errors: returns descriptive strings (not exceptions) - "All scroll strategies failed", "Browser not open" | screenshot comparison failure returns True (assumes different) to continue | page.evaluate() exceptions caught and next strategy tried | prints debug output to stdout
+  ⚠️ Strategy order: AI-first may be slower but more accurate for complex sites (Gmail) - reorder if speed critical
+  ⚠️ Screenshot verification: 1% threshold may need tuning for high-resolution displays or subtle animations
+"""
+
+from typing import Callable, List, Tuple
+from pydantic import BaseModel
+from connectonion import llm_do
+
+
+class ScrollStrategy(BaseModel):
+    """AI-generated scroll strategy."""
+    javascript: str
+    explanation: str
+
+
+def scroll_with_verification(
+    page,
+    take_screenshot: Callable,
+    times: int = 5,
+    description: str = "the main content area"
+) -> str:
+    """Universal scroll with automatic strategy selection and fallback.
+
+    Tries multiple strategies in order until one works:
+    1. AI-generated strategy (default)
+    2. Element scrolling
+    3. Page scrolling
+
+    Args:
+        page: Playwright page object
+        take_screenshot: Function to take screenshots
+        times: Number of scroll iterations
+        description: What to scroll (natural language)
+
+    Returns:
+        Status message with successful strategy
+    """
+    if not page:
+        return "Browser not open"
+
+    print(f"\n📜 Starting universal scroll for: '{description}'")
+
+    import time
+    timestamp = int(time.time())
+    before_file = f"scroll_before_{timestamp}.png"
+    after_file = f"scroll_after_{timestamp}.png"
+
+    # Take before screenshot
+    take_screenshot(before_file)
+
+    strategies = [
+        ("AI-generated strategy", lambda: ai_scroll_strategy(page, times, description)),
+        ("Element scrolling", lambda: element_scroll_strategy(page, times)),
+        ("Page scrolling", lambda: page_scroll_strategy(page, times))
+    ]
+
+    for strategy_name, strategy_func in strategies:
+        print(f"\n  Trying: {strategy_name}...")
+
+        try:
+            strategy_func()
+            time.sleep(1)
+
+            # Take after screenshot
+            take_screenshot(after_file)
+
+            # Verify scroll worked
+            if screenshots_are_different(before_file, after_file):
+                print(f"  ✅ {strategy_name} WORKED! Content changed.")
+                return f"Scroll successful using {strategy_name}. Check {before_file} vs {after_file}"
+            else:
+                print(f"  ⚠️  {strategy_name} didn't change content. Trying next...")
+                before_file = after_file
+                after_file = f"scroll_after_{timestamp}_next.png"
+
+        except Exception as e:
+            print(f"  ❌ {strategy_name} failed: {e}")
+            continue
+
+    return "All scroll strategies failed. No visible content change."
+
+
+def screenshots_are_different(file1: str, file2: str) -> bool:
+    """Compare screenshots to verify content changed.
+
+    Args:
+        file1: First screenshot filename
+        file2: Second screenshot filename
+
+    Returns:
+        True if screenshots are different
+    """
+    try:
+        from PIL import Image
+        import os
+
+        path1 = os.path.join("screenshots", file1)
+        path2 = os.path.join("screenshots", file2)
+
+        img1 = Image.open(path1).convert('RGB')
+        img2 = Image.open(path2).convert('RGB')
+
+        # Calculate pixel difference
+        diff = sum(
+            abs(a - b)
+            for pixel1, pixel2 in zip(img1.getdata(), img2.getdata())
+            for a, b in zip(pixel1, pixel2)
+        )
+
+        # 1% threshold
+        threshold = img1.size[0] * img1.size[1] * 3 * 0.01
+
+        is_different = diff > threshold
+        print(f"    Screenshot diff: {diff:.0f} (threshold: {threshold:.0f}) - {'DIFFERENT' if is_different else 'SAME'}")
+
+        return is_different
+
+    except Exception as e:
+        print(f"    Warning: Screenshot comparison failed: {e}")
+        return True  # Assume different if comparison fails
+
+
+def ai_scroll_strategy(page, times: int, description: str):
+    """AI-generated scroll strategy.
+
+    Analyzes page structure and generates custom JavaScript.
+    """
+    # Find scrollable elements
+    scrollable_elements = page.evaluate("""
+        (() => {
+            const scrollable = [];
+            document.querySelectorAll('*').forEach(el => {
+                const style = window.getComputedStyle(el);
+                if ((style.overflow === 'auto' || style.overflowY === 'scroll') &&
+                    el.scrollHeight > el.clientHeight) {
+                    scrollable.push({
+                        tag: el.tagName,
+                        classes: el.className,
+                        id: el.id
+                    });
+                }
+            });
+            return scrollable;
+        })()
+    """)
+
+    # Get simplified HTML
+    simplified_html = page.evaluate("""
+        (() => {
+            const clone = document.body.cloneNode(true);
+            clone.querySelectorAll('script, style, img, svg').forEach(el => el.remove());
+            return clone.innerHTML.substring(0, 5000);
+        })()
+    """)
+
+    # Generate scroll strategy using AI
+    strategy = llm_do(
+        f"""Generate JavaScript to scroll "{description}".
+
+Scrollable elements: {scrollable_elements[:3]}
+HTML structure: {simplified_html}
+
+Return IIFE that scrolls the correct element:
+(() => {{
+  const el = document.querySelector('.selector');
+  if (el) el.scrollTop += 1000;
+  return {{success: true}};
+}})()
+""",
+        output=ScrollStrategy,
+        model="gpt-4o",
+        temperature=0.1
+    )
+
+    print(f"    AI generated: {strategy.explanation}")
+
+    # Execute scroll
+    import time
+    for i in range(times):
+        page.evaluate(strategy.javascript)
+        time.sleep(1.2)
+
+
+def element_scroll_strategy(page, times: int):
+    """Scroll first scrollable element found."""
+    import time
+    for i in range(times):
+        page.evaluate("""
+            (() => {
+                const el = Array.from(document.querySelectorAll('*')).find(e => {
+                    const s = window.getComputedStyle(e);
+                    return (s.overflow === 'auto' || s.overflowY === 'scroll') &&
+                           e.scrollHeight > e.clientHeight;
+                });
+                if (el) el.scrollTop += 1000;
+            })()
+        """)
+        time.sleep(1)
+
+
+def page_scroll_strategy(page, times: int):
+    """Scroll the page window."""
+    import time
+    for i in range(times):
+        page.evaluate("window.scrollBy(0, 1000)")
+        time.sleep(1)
+
+
+# Additional scroll helpers that can be called directly
+def scroll_page(page, direction: str = "down", amount: int = 1000) -> str:
+    """Scroll the page in a specific direction.
+
+    Args:
+        page: Playwright page object
+        direction: "down", "up", "top", or "bottom"
+        amount: Pixels to scroll
+
+    Returns:
+        Status message
+    """
+    if not page:
+        return "Browser not open"
+
+    if direction == "bottom":
+        page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
+        return "Scrolled to bottom of page"
+    elif direction == "top":
+        page.evaluate("window.scrollTo(0, 0)")
+        return "Scrolled to top of page"
+    elif direction == "down":
+        page.evaluate(f"window.scrollBy(0, {amount})")
+        return f"Scrolled down {amount} pixels"
+    elif direction == "up":
+        page.evaluate(f"window.scrollBy(0, -{amount})")
+        return f"Scrolled up {amount} pixels"
+    else:
+        return f"Unknown direction: {direction}"
+
+
+def scroll_element(page, selector: str, amount: int = 1000) -> str:
+    """Scroll a specific element by CSS selector.
+
+    Args:
+        page: Playwright page object
+        selector: CSS selector for the element
+        amount: Pixels to scroll
+
+    Returns:
+        Status message
+    """
+    if not page:
+        return "Browser not open"
+
+    result = page.evaluate(f"""
+        (() => {{
+            const element = document.querySelector('{selector}');
+            if (!element) return 'Element not found: {selector}';
+
+            const beforeScroll = element.scrollTop;
+            element.scrollTop += {amount};
+            const afterScroll = element.scrollTop;
+
+            return `Scrolled from ${{beforeScroll}}px to ${{afterScroll}}px (delta: ${{afterScroll - beforeScroll}}px)`;
+        }})()
+    """)
+
+    return result

connectonion/cli/commands/eval_commands.py

@@ -0,0 +1,286 @@
+"""
+Purpose: CLI command for running and managing evals
+LLM-Note:
+  Dependencies: imports from [pathlib, yaml, json, rich, importlib] | imported by [cli/main.py]
+  Data flow: handle_eval() → reads .co/evals/*.yaml → imports agent → runs with stored input → compares expected vs output
+  Integration: exposes handle_eval(name, run) for CLI
+
+Eval YAML format:
+  - `turns`: List of inputs to send to agent sequentially (like a conversation).
+    Each turn can have one input. Turns run in order within same agent session,
+    simulating multi-round conversations. Use single turn for simple evals,
+    or multiple turns to test conversation flow.
+"""
+
+import importlib.util
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from pydantic import BaseModel
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+class JudgeResult(BaseModel):
+    """Result from LLM judge evaluation."""
+    passed: bool
+    analysis: str
+
+
+def get_agent_from_file(file_path: str, cwd: str):
+    """Import agent instance from file."""
+    from connectonion import Agent
+
+    if not os.path.isabs(file_path):
+        file_path = os.path.join(cwd, file_path)
+
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+    spec = importlib.util.spec_from_file_location("agent_module", file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    if hasattr(module, 'agent') and isinstance(module.agent, Agent):
+        agent = module.agent
+        agent.logger.enable_sessions = False  # Prevent duplicate eval files
+        return agent
+
+    raise ValueError(
+        f"No 'agent' instance found in {file_path}.\n\n"
+        f"Structure your file like this:\n\n"
+        f"    agent = Agent(...)\n\n"
+        f"    if __name__ == '__main__':\n"
+        f"        agent.input('...')\n"
+    )
+
+
+def handle_eval(name: Optional[str] = None, agent_file: Optional[str] = None):
+    """Run evals and show results.
+
+    Args:
+        name: Optional specific eval name to run
+        agent_file: Optional agent file path (overrides YAML setting)
+    """
+    evals_dir = Path(".co/evals")
+
+    if not evals_dir.exists():
+        console.print("[yellow]No evals found.[/yellow]")
+        console.print("[dim]Create eval files in .co/evals/*.yaml[/dim]")
+        return
+
+    if name:
+        eval_files = list(evals_dir.glob(f"{name}.yaml"))
+        if not eval_files:
+            console.print(f"[red]Eval not found: {name}[/red]")
+            return
+    else:
+        eval_files = list(evals_dir.glob("*.yaml"))
+
+    if not eval_files:
+        console.print("[yellow]No eval files found in .co/evals/[/yellow]")
+        return
+
+    _run_evals(eval_files, agent_file)
+
+    # Reload and show status
+    if name:
+        eval_files = list(evals_dir.glob(f"{name}.yaml"))
+    else:
+        eval_files = list(evals_dir.glob("*.yaml"))
+
+    _show_eval_status(eval_files)
+
+
+def _run_evals(eval_files: list, agent_override: Optional[str] = None):
+    """Run agents for each eval and capture output."""
+    cwd = os.getcwd()
+    agents_cache = {}  # Cache agents by file path
+
+    for eval_file in eval_files:
+        with open(eval_file) as f:
+            data = yaml.safe_load(f)
+
+        # Get agent file: CLI override > YAML > error
+        agent_file = agent_override or data.get('agent')
+        if not agent_file:
+            console.print(f"[red]No agent specified for {eval_file.stem}[/red]")
+            console.print(f"[dim]Add 'agent: agent.py' to the YAML or use --agent flag[/dim]")
+            continue
+
+        # Load agent (cached)
+        if agent_file not in agents_cache:
+            console.print(f"[cyan]Loading:[/cyan] {agent_file}")
+            agents_cache[agent_file] = get_agent_from_file(agent_file, cwd)
+        agent = agents_cache[agent_file]
+
+        turns = data.get('turns', [])
+        if not turns:
+            console.print(f"[yellow]No turns found in {eval_file.stem}[/yellow]")
+            continue
+
+        console.print(f"[cyan]Running:[/cyan] {eval_file.stem}")
+
+        # Reset agent session for fresh state each eval
+        agent.reset_conversation()
+
+        file_modified = False
+        for turn in turns:
+            input_text = turn.get('input', '')
+            if not input_text:
+                continue
+
+            # Show input (truncated)
+            display_input = input_text[:60] + "..." if len(input_text) > 60 else input_text
+            console.print(f"  [dim]input:[/dim] {display_input}")
+
+            # Run agent and capture result
+            result = agent.input(input_text)
+
+            # Extract tools_called and metrics from agent session
+            trace = agent.current_session.get('trace', [])
+            tool_calls = [t for t in trace if t.get('type') == 'tool_execution']
+            llm_calls = [t for t in trace if t.get('type') == 'llm_call']
+            tools_called = [agent.logger._format_tool_call(t) for t in tool_calls]
+
+            total_tokens = sum(
+                (t.get('usage').input_tokens + t.get('usage').output_tokens)
+                for t in llm_calls if t.get('usage')
+            )
+            total_cost = sum(
+                t.get('usage').cost for t in llm_calls if t.get('usage')
+            )
+
+            # Build history as JSON array string (compact, easy to scan)
+            history_str = turn.get('history', '[]')
+            history = json.loads(history_str) if isinstance(history_str, str) else []
+            if turn.get('output'):
+                history.insert(0, {
+                    "ts": turn.get('ts', ''),
+                    "pass": turn.get('pass'),
+                    "tokens": turn.get('tokens', 0),
+                    "cost": turn.get('cost', 0)
+                })
+
+            # Store result in turn
+            turn['output'] = result
+            turn['tools_called'] = tools_called
+            turn['tokens'] = total_tokens
+            turn['cost'] = round(total_cost, 4)
+            turn['ts'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            turn['run'] = data.get('runs', 0) + 1
+            # Format history as multi-line JSON for readability
+            if history:
+                lines = [json.dumps(h) for h in history]
+                turn['history'] = "[\n" + ",\n".join(lines) + "]"
+            else:
+                turn['history'] = "[]"
+            file_modified = True
+
+            # Judge immediately if expected exists
+            expected = turn.get('expected', '')
+            if expected:
+                judge = _judge_with_llm(expected, result, input_text)
+                turn['pass'] = judge.passed
+                turn['analysis'] = judge.analysis
+                status = "[green]✓[/green]" if judge.passed else "[red]✗[/red]"
+                console.print(f"  {status} {judge.analysis[:60]}...")
+            else:
+                # Show output (truncated)
+                display_output = result[:60] + "..." if len(result) > 60 else result
+                console.print(f"  [green]output:[/green] {display_output}")
+
+        if file_modified:
+            # Update runs count and save
+            data['runs'] = data.get('runs', 0) + 1
+            data['updated'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            with open(eval_file, 'w') as f:
+                yaml.dump(data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
+        console.print(f"[green]✓[/green] {eval_file.stem} completed")
+        console.print()
+
+    console.print()
+
+
+def _judge_with_llm(expected: str, output: str, input_text: str) -> JudgeResult:
+    """Use LLM to judge if output matches expected."""
+    from connectonion import llm_do
+
+    prompt = f"""You are an eval judge. Determine if the agent's output satisfies the expected criteria.
+
+Input: {input_text}
+Expected: {expected}
+Output: {output}
+
+Does the output satisfy the expected criteria? Consider:
+- Semantic similarity (not exact match)
+- Key information presence
+- Intent fulfillment
+"""
+    return llm_do(prompt, output=JudgeResult)
+
+
+def _show_eval_status(eval_files: list):
+    """Show pass/fail status for all evals (uses stored results, no re-judging)."""
+    table = Table(title="Eval Results", show_header=True)
+    table.add_column("Eval", style="cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Expected", max_width=30)
+    table.add_column("Output", max_width=30)
+
+    passed = 0
+    failed = 0
+    no_expected = 0
+
+    for eval_file in sorted(eval_files):
+        with open(eval_file) as f:
+            data = yaml.safe_load(f)
+
+        for turn in data.get('turns', []):
+            expected = turn.get('expected', '')
+            output = turn.get('output', '')
+            pass_result = turn.get('pass')
+
+            if not expected:
+                status = "[dim]—[/dim]"
+                no_expected += 1
+            elif pass_result is True:
+                status = "[green]✓ pass[/green]"
+                passed += 1
+            elif pass_result is False:
+                status = "[red]✗ fail[/red]"
+                failed += 1
+            else:
+                status = "[dim]pending[/dim]"
+                no_expected += 1
+
+            # Truncate for display
+            expected_display = (expected[:27] + "...") if len(expected) > 30 else expected
+            output_display = (output[:27] + "...") if len(output) > 30 else output
+
+            table.add_row(
+                eval_file.stem,
+                status,
+                expected_display or "[dim]not set[/dim]",
+                output_display
+            )
+
+    console.print(table)
+    console.print()
+
+    # Summary
+    if failed > 0:
+        console.print(f"[bold red]✗ {failed} failed[/bold red], ", end="")
+    if passed > 0:
+        console.print(f"[bold green]✓ {passed} passed[/bold green], ", end="")
+    if no_expected > 0:
+        console.print(f"[dim]{no_expected} no expected[/dim]", end="")
+    console.print()

connectonion/cli/main.py

@@ -55,6 +55,7 @@ def _show_help():
     console.print("  [green]create[/green]  <name>     Create new project")
     console.print("  [green]init[/green]              Initialize in current directory")
     console.print("  [green]copy[/green]   <name>     Copy tool/plugin source to project")
+    console.print("  [green]eval[/green]              Run evals and show status")
     console.print("  [green]deploy[/green]            Deploy to ConnectOnion Cloud")
     console.print("  [green]auth[/green]              Authenticate for managed keys")
     console.print("  [green]status[/green]            Check account balance")
@@ -152,6 +153,16 @@ def copy(
     handle_copy(names=names or [], list_all=list_all, path=path, force=force)
 
 
+@app.command()
+def eval(
+    name: Optional[str] = typer.Argument(None, help="Specific eval name"),
+    agent: Optional[str] = typer.Option(None, "--agent", "-a", help="Agent file (overrides YAML)"),
+):
+    """Run evals and show results."""
+    from .commands.eval_commands import handle_eval
+    handle_eval(name=name, agent_file=agent)
+
+
 def cli():
     """Entry point."""
     app()

connectonion/console.py

@@ -110,7 +110,7 @@ class Console:
         ●     ─────────────────────
               connectonion v0.5.1
               o4-mini · 3 tools
-              .co/logs/ · .co/sessions/
+              .co/logs/ · .co/evals/
 
         Args:
             agent_name: Name of the agent
@@ -156,7 +156,7 @@ class Console:
 
         # Add log paths if logging is enabled
         if log_dir:
-            lines.append(f"      [{DIM_COLOR}]{log_dir}logs/ · {log_dir}sessions/[/{DIM_COLOR}]")
+            lines.append(f"      [{DIM_COLOR}]{log_dir}logs/ · {log_dir}evals/[/{DIM_COLOR}]")
 
         # Add Aaron's message for free tier users
         if aaron_message:
@@ -182,7 +182,7 @@ class Console:
             if meta_line:
                 plain_lines.append(f"      {meta_line}")
             if log_dir:
-                plain_lines.append(f"      {log_dir}logs/ · {log_dir}sessions/")
+                plain_lines.append(f"      {log_dir}logs/ · {log_dir}evals/")
             if aaron_message:
                 plain_lines.append(f"      {aaron_message}")
             plain_lines.append(f"      {separator}")
@@ -484,12 +484,12 @@ class Console:
 
         [co] ═══════════════════════════════════════
         [co] ✓ done · 2.3k tokens · $0.005 · 3.4s
-        [co]   saved → .co/sessions/research-assistant.yaml
+        [co]   saved → .co/evals/research-assistant.yaml
 
         Args:
             duration_s: Total duration in seconds
             session: Agent's current_session dict (contains trace with usage)
-            session_path: Optional path to session file
+            session_path: Optional path to eval file
         """
         # Calculate totals from trace
         trace = session.get('trace', [])

connectonion/core/agent.py

@@ -2,9 +2,9 @@
 Purpose: Orchestrate AI agent execution with LLM calls, tool execution, and automatic logging
 LLM-Note:
   Dependencies: imports from [llm.py, tool_factory.py, prompts.py, decorators.py, logger.py, tool_executor.py, tool_registry.py] | imported by [__init__.py, debug_agent/__init__.py] | tested by [tests/test_agent.py, tests/test_agent_prompts.py, tests/test_agent_workflows.py]
-  Data flow: receives user prompt: str from Agent.input() → creates/extends current_session with messages → calls llm.complete() with tool schemas → receives LLMResponse with tool_calls → executes tools via tool_executor.execute_and_record_tools() → appends tool results to messages → repeats loop until no tool_calls or max_iterations → logger logs to .co/logs/{name}.log and .co/sessions/{name}_{timestamp}.yaml → returns final response: str
-  State/Effects: modifies self.current_session['messages', 'trace', 'turn', 'iteration'] | writes to .co/logs/{name}.log and .co/sessions/ via logger.py
-  Integration: exposes Agent(name, tools, system_prompt, model, log, quiet), .input(prompt), .execute_tool(name, args), .add_tool(func), .remove_tool(name), .list_tools(), .reset_conversation() | tools stored in ToolRegistry with attribute access (agent.tools.tool_name) and instance storage (agent.tools.gmail) | tool execution delegates to tool_executor module | log defaults to .co/logs/ (None), can be True (current dir), False (disabled), or custom path | quiet=True suppresses console but keeps session logging | trust enforcement moved to host() for network access control
+  Data flow: receives user prompt: str from Agent.input() → creates/extends current_session with messages → calls llm.complete() with tool schemas → receives LLMResponse with tool_calls → executes tools via tool_executor.execute_and_record_tools() → appends tool results to messages → repeats loop until no tool_calls or max_iterations → logger logs to .co/logs/{name}.log and .co/evals/{name}.yaml → returns final response: str
+  State/Effects: modifies self.current_session['messages', 'trace', 'turn', 'iteration'] | writes to .co/logs/{name}.log and .co/evals/ via logger.py
+  Integration: exposes Agent(name, tools, system_prompt, model, log, quiet), .input(prompt), .execute_tool(name, args), .add_tool(func), .remove_tool(name), .list_tools(), .reset_conversation() | tools stored in ToolRegistry with attribute access (agent.tools.tool_name) and instance storage (agent.tools.gmail) | tool execution delegates to tool_executor module | log defaults to .co/logs/ (None), can be True (current dir), False (disabled), or custom path | quiet=True suppresses console but keeps eval logging | trust enforcement moved to host() for network access control
   Performance: max_iterations=10 default (configurable per-input) | session state persists across turns for multi-turn conversations | ToolRegistry provides O(1) tool lookup via .get() or attribute access
   Errors: LLM errors bubble up | tool execution errors captured in trace and returned to LLM for retry
 """
@@ -51,11 +51,14 @@ class Agent:
         # Current session context (runtime only)
         self.current_session = None
 
+        # Connection to client (None locally, injected by host() for WebSocket)
+        self.connection = None
+
         # Token usage tracking
         self.total_cost: float = 0.0  # Cumulative cost in USD
         self.last_usage: Optional[TokenUsage] = None  # From most recent LLM call
 
-        # Initialize logger (unified: terminal + file + YAML sessions)
+        # Initialize logger (unified: terminal + file + YAML evals)
         # Environment variable override (highest priority)
         effective_log = log
         if os.getenv('CONNECTONION_LOG'):
@@ -250,16 +253,16 @@ class Agent:
 
         self.current_session['result'] = result
 
-        # Print completion summary
-        if self.logger.console:
-            session_path = f".co/sessions/{self.name}.yaml" if self.logger.enable_sessions else None
-            self.logger.console.print_completion(duration, self.current_session, session_path)
-
         self._invoke_events('on_complete')
 
-        # Log turn to YAML session (after on_complete so handlers can modify state)
+        # Log turn to YAML eval (after on_complete so handlers can modify state)
         self.logger.log_turn(prompt, result, duration * 1000, self.current_session, self.llm.model)
 
+        # Print completion summary (after log_turn so we have the eval path)
+        if self.logger.console:
+            eval_path = self.logger.get_eval_path()
+            self.logger.console.print_completion(duration, self.current_session, eval_path)
+
         return result
 
     def reset_conversation(self):