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

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/__init__.py

@@ -0,0 +1,53 @@
+"""Core agent execution engine.
+
+This module contains the minimal set of components needed to run an agent:
+- Agent: Main orchestrator
+- LLM: Multi-provider LLM abstraction
+- Events: Event system for lifecycle hooks
+- Tools: Tool execution, factory, and registry
+- Usage: Token tracking and cost calculation
+"""
+
+from .agent import Agent
+from .llm import LLM, create_llm, TokenUsage
+from .events import (
+    EventHandler,
+    after_user_input,
+    before_llm,
+    after_llm,
+    before_each_tool,
+    before_tools,
+    after_each_tool,
+    after_tools,
+    on_error,
+    on_complete,
+)
+from .tool_factory import create_tool_from_function, extract_methods_from_instance, is_class_instance
+from .tool_registry import ToolRegistry
+from .tool_executor import execute_and_record_tools, execute_single_tool
+from .usage import TokenUsage, calculate_cost, get_context_limit
+
+__all__ = [
+    "Agent",
+    "LLM",
+    "create_llm",
+    "TokenUsage",
+    "EventHandler",
+    "after_user_input",
+    "before_llm",
+    "after_llm",
+    "before_each_tool",
+    "before_tools",
+    "after_each_tool",
+    "after_tools",
+    "on_error",
+    "on_complete",
+    "create_tool_from_function",
+    "extract_methods_from_instance",
+    "is_class_instance",
+    "ToolRegistry",
+    "execute_and_record_tools",
+    "execute_single_tool",
+    "calculate_cost",
+    "get_context_limit",
+]

connectonion/{agent.py → 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
 """
@@ -18,11 +18,11 @@ from .llm import LLM, create_llm, TokenUsage
 from .usage import get_context_limit
 from .tool_factory import create_tool_from_function, extract_methods_from_instance, is_class_instance
 from .tool_registry import ToolRegistry
-from .prompts import load_system_prompt
-from .decorators import (
+from ..prompts import load_system_prompt
+from ..debug.decorators import (
     _is_replay_enabled  # Only need this for replay check
 )
-from .logger import Logger
+from ..logger import Logger
 from .tool_executor import execute_and_record_tools, execute_single_tool
 from .events import EventHandler
 
@@ -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):
@@ -444,7 +447,7 @@ class Agent:
             # Single prompt mode
             agent.auto_debug("Find information about Python")
         """
-        from .interactive_debugger import InteractiveDebugger
-        debugger = InteractiveDebugger(self)
+        from .debug import AutoDebugger
+        debugger = AutoDebugger(self)
         debugger.start_debug_session(prompt)
 

connectonion/{llm.py → core/llm.py}

@@ -734,28 +734,18 @@ class OpenOnionLLM(LLM):
         )
 
     def structured_complete(self, messages: List[Dict], output_schema: Type[BaseModel], **kwargs) -> BaseModel:
-        """Get structured Pydantic output using OpenAI-compatible API."""
-        response = self.client.responses.parse(
+        """Get structured Pydantic output using OpenAI-compatible chat completions API.
+
+        Uses beta.chat.completions.parse() which routes through /v1/chat/completions,
+        allowing proper provider routing for Gemini, OpenAI, and other models.
+        """
+        completion = self.client.beta.chat.completions.parse(
             model=self.model,
-            input=messages,
-            text_format=output_schema,
+            messages=messages,
+            response_format=output_schema,
             **kwargs
         )
-
-        # Handle edge cases
-        if response.status == "incomplete":
-            if response.incomplete_details.reason == "max_output_tokens":
-                raise ValueError("Response incomplete: maximum output tokens reached")
-            elif response.incomplete_details.reason == "content_filter":
-                raise ValueError("Response incomplete: content filtered")
-
-        # Check for refusal
-        if response.output and len(response.output) > 0:
-            first_content = response.output[0].content[0] if response.output[0].content else None
-            if first_content and hasattr(first_content, 'type') and first_content.type == "refusal":
-                raise ValueError(f"Model refused to respond: {first_content.refusal}")
-
-        return response.output_parsed
+        return completion.choices[0].message.parsed
 
 
 def create_llm(model: str, api_key: Optional[str] = None, **kwargs) -> LLM:

connectonion/{tool_executor.py → core/tool_executor.py}

@@ -13,7 +13,7 @@ import time
 import json
 from typing import List, Dict, Any, Optional, Callable
 
-from .xray import (
+from ..debug.xray import (
     inject_xray_context,
     clear_xray_context,
     is_xray_enabled
@@ -165,7 +165,8 @@ def execute_single_tool(
         agent.current_session['pending_tool'] = {
             'name': tool_name,
             'arguments': tool_args,
-            'id': tool_id
+            'id': tool_id,
+            'description': getattr(tool_func, 'description', '')
         }
 
         # Invoke before_each_tool events

connectonion/{tool_factory.py → core/tool_factory.py}

@@ -29,7 +29,9 @@ def create_tool_from_function(func: Callable) -> Callable:
     by inspecting its signature and docstring.
     """
     name = func.__name__
-    description = inspect.getdoc(func) or f"Execute the {name} tool."
+    raw_doc = inspect.getdoc(func)
+    # Extract summary only (first paragraph) - Args/Returns sections are not sent to LLM
+    description = raw_doc.split('\n\n')[0].strip() if raw_doc else f"Execute the {name} tool."
 
     # Build the parameters schema from the function signature
     sig = inspect.signature(func)

connectonion/debug/__init__.py

@@ -0,0 +1,51 @@
+"""Debug tools for agent development and troubleshooting.
+
+This module contains:
+- xray: Runtime context injection for tool inspection
+- decorators: replay, xray_replay for debugging
+- auto_debug: Interactive debugging with breakpoints (AutoDebugger, AutoDebugUI)
+- auto_debug_exception: Exception handling and debugging
+- runtime_inspector: AI-powered runtime state inspection for crash debugging
+- debug_explainer: AI-powered explanation of tool choices
+
+Note: Uses lazy imports to avoid circular dependency with agent.py
+"""
+
+# xray and decorators can be imported eagerly (no circular dependency)
+from .xray import xray
+from .decorators import replay, xray_replay
+
+__all__ = [
+    "xray",
+    "replay",
+    "xray_replay",
+    "AutoDebugger",
+    "AutoDebugUI",
+    "BreakpointContext",
+    "BreakpointAction",
+    "auto_debug_exception",
+    "create_debug_agent",
+    "RuntimeInspector",
+    "explain_tool_choice",
+    "RuntimeContext",
+]
+
+
+def __getattr__(name):
+    """Lazy import to avoid circular dependency with agent.py."""
+    if name == "AutoDebugger":
+        from .auto_debug import AutoDebugger
+        return AutoDebugger
+    elif name in ("AutoDebugUI", "BreakpointContext", "BreakpointAction"):
+        from .auto_debug_ui import AutoDebugUI, BreakpointContext, BreakpointAction
+        return {"AutoDebugUI": AutoDebugUI, "BreakpointContext": BreakpointContext, "BreakpointAction": BreakpointAction}[name]
+    elif name == "auto_debug_exception":
+        from .auto_debug_exception import auto_debug_exception
+        return auto_debug_exception
+    elif name in ("create_debug_agent", "RuntimeInspector"):
+        from .runtime_inspector import create_debug_agent, RuntimeInspector
+        return {"create_debug_agent": create_debug_agent, "RuntimeInspector": RuntimeInspector}[name]
+    elif name in ("explain_tool_choice", "RuntimeContext"):
+        from .debug_explainer import explain_tool_choice, RuntimeContext
+        return {"explain_tool_choice": explain_tool_choice, "RuntimeContext": RuntimeContext}[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

connectonion/{interactive_debugger.py → debug/auto_debug.py}

@@ -13,25 +13,25 @@ LLM-Note:
 """
 
 from typing import Any, Dict, Optional, List
-from .debugger_ui import DebuggerUI, BreakpointContext, BreakpointAction
+from .auto_debug_ui import AutoDebugUI, BreakpointContext, BreakpointAction
 
 
-class InteractiveDebugger:
+class AutoDebugger:
     """Orchestrates debugging sessions for AI agents.
 
     This class handles the debugging logic and intercepts tool execution,
     delegating all UI interactions to the DebuggerUI class.
     """
 
-    def __init__(self, agent: Any, ui: Optional[DebuggerUI] = None):
+    def __init__(self, agent: Any, ui: Optional[AutoDebugUI] = None):
         """Initialize debugger with an agent instance and optional UI.
 
         Args:
             agent: The Agent instance to debug
-            ui: Optional DebuggerUI instance (creates default if None)
+            ui: Optional AutoDebugUI instance (creates default if None)
         """
         self.agent = agent
-        self.ui = ui or DebuggerUI()
+        self.ui = ui or AutoDebugUI()
         self.original_execute_single_tool = None
 
     def start_debug_session(self, prompt: Optional[str] = None):
@@ -99,7 +99,7 @@ class InteractiveDebugger:
         - Pause execution and show UI if breakpoint conditions are met
         - Only affect this specific agent instance
         """
-        from . import tool_executor
+        from ..core import tool_executor
         from .xray import is_xray_enabled
 
         # Store original function for restoration later
@@ -141,7 +141,7 @@ class InteractiveDebugger:
         tool execution function.
         """
         if self.original_execute_single_tool:
-            from . import tool_executor
+            from ..core import tool_executor
             tool_executor.execute_single_tool = self.original_execute_single_tool
 
     def _show_breakpoint_ui_and_wait_for_continue(self, tool_name: str, tool_args: Dict, trace_entry: Dict):

connectonion/{auto_debug_exception.py → debug/auto_debug_exception.py}

@@ -57,7 +57,7 @@ def auto_debug_exception(model: str = "o4-mini"):
         original_hook(exc_type, exc_value, exception_traceback)
 
         # Then add our AI analysis
-        from .console import Console
+        from ..console import Console
         console = Console()
 
         # Find the most relevant frame (last user code, not library)
@@ -125,7 +125,7 @@ def auto_debug_exception(model: str = "o4-mini"):
 
         try:
             # Use debug agent with runtime inspection tools
-            from .debug_agent import create_debug_agent
+            from .runtime_inspector import create_debug_agent
 
             # Pass the actual frame and traceback for runtime inspection!
             agent = create_debug_agent(
@@ -176,6 +176,6 @@ You have LIVE ACCESS to the crashed program's state! Use your tools to investiga
     sys.excepthook = handle_exception
 
     # Simple confirmation
-    from .console import Console
+    from ..console import Console
     console = Console()
     console.print(f"[green]✅ Exception debugging enabled[/green] - AI will analyze uncaught exceptions with runtime inspection")

connectonion/{debugger_ui.py → debug/auto_debug_ui.py}

@@ -51,7 +51,7 @@ class BreakpointContext:
     tool_function: Optional[Any] = None  # The actual tool function for source inspection
 
 
-class DebuggerUI:
+class AutoDebugUI:
     """Handles all user interaction and display for the debugger."""
 
     def __init__(self):

connectonion/{debug_explainer → debug/debug_explainer}/explain_agent.py

@@ -31,7 +31,7 @@ def explain_tool_choice(
     Returns:
         Explanation string from the AI agent
     """
-    from ..agent import Agent
+    from ...core.agent import Agent
     import inspect
 
     # Get all the information we need

connectonion/{debug_explainer → debug/debug_explainer}/explain_context.py

@@ -12,7 +12,7 @@ LLM-Note:
 from typing import Dict, List, Any
 from pathlib import Path
 from pydantic import BaseModel
-from ..llm_do import llm_do
+from ...llm_do import llm_do
 
 
 class RootCauseAnalysis(BaseModel):

connectonion/{execution_analyzer → debug/execution_analyzer}/execution_analysis.py

@@ -16,7 +16,7 @@ Analyzes the entire execution trace and provides suggestions for improvement.
 from pathlib import Path
 from pydantic import BaseModel
 from typing import List
-from ..llm_do import llm_do
+from ...llm_do import llm_do
 
 
 class ExecutionAnalysis(BaseModel):

connectonion/debug/runtime_inspector/__init__.py

@@ -0,0 +1,13 @@
+"""Runtime inspector for AI-powered crash debugging.
+
+Provides RuntimeInspector class and factory function to create debug agents
+that can experiment, test, and validate fixes using actual crashed program data.
+"""
+
+from .agent import create_debug_agent
+from .runtime_inspector import RuntimeInspector
+
+__all__ = [
+    "create_debug_agent",
+    "RuntimeInspector"
+]

connectonion/{debug_agent → debug/runtime_inspector}/agent.py

@@ -10,7 +10,7 @@ LLM-Note:
 """
 
 from pathlib import Path
-from ..agent import Agent
+from ...core.agent import Agent
 from .runtime_inspector import RuntimeInspector
 
 

connectonion/{xray.py → debug/xray.py}

@@ -14,7 +14,7 @@ This module provides the @xray decorator and xray context for debugging AI agent
 See everything your agent is thinking during tool execution.
 
 Usage:
-    from connectonion.xray import xray
+    from connectonion import xray  # or: from connectonion.debug import xray
 
     @xray
     def my_tool(query: str):

connectonion/llm_do.py

@@ -222,7 +222,7 @@ from typing import Union, Type, Optional, TypeVar
 from pathlib import Path
 from pydantic import BaseModel
 from .prompts import load_system_prompt
-from .llm import create_llm
+from .core.llm import create_llm
 
 T = TypeVar('T', bound=BaseModel)