connectonion 0.5.7__tar.gz → 0.5.9__tar.gz

{connectonion-0.5.7 → connectonion-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: connectonion
-Version: 0.5.7
+Version: 0.5.9
 Summary: A simple Python framework for creating AI agents with behavior tracking
 Project-URL: Homepage, https://github.com/openonion/connectonion
 Project-URL: Documentation, https://docs.connectonion.com

{connectonion-0.5.7 → connectonion-0.5.9}/connectonion/__init__.py

@@ -1,6 +1,6 @@
 """ConnectOnion - A simple agent framework with behavior tracking."""
 
-__version__ = "0.5.7"
+__version__ = "0.5.9"
 
 # Auto-load .env files for the entire framework
 from dotenv import load_dotenv
@@ -15,6 +15,7 @@ from .tool_factory import create_tool_from_function
 from .llm import LLM
 from .logger import Logger
 from .llm_do import llm_do
+from .transcribe import transcribe
 from .prompts import load_system_prompt
 from .xray import xray
 from .decorators import replay, xray_replay
@@ -40,6 +41,7 @@ __all__ = [
     "Logger",
     "create_tool_from_function",
     "llm_do",
+    "transcribe",
     "load_system_prompt",
     "xray",
     "replay",

connectonion-0.5.9/connectonion/cli/commands/copy_commands.py

@@ -0,0 +1,116 @@
+"""
+Purpose: CLI command to copy built-in tools and plugins to user's project for customization
+LLM-Note:
+  Dependencies: imports from [shutil, pathlib, typing, rich] | imported by [cli/main.py via handle_copy()]
+  Data flow: user runs `co copy <name>` → looks up name in TOOLS/PLUGINS registry → finds source via module.__file__ → copies to ./tools/ or ./plugins/
+  State/Effects: creates tools/ or plugins/ directory if needed | copies .py files from installed package to user's project
+  Integration: exposes handle_copy() for CLI | uses Python import system to find installed package location (cross-platform)
+"""
+
+import shutil
+from pathlib import Path
+from typing import Optional, List
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+# Registry of copyable tools
+TOOLS = {
+    "gmail": "gmail.py",
+    "outlook": "outlook.py",
+    "google_calendar": "google_calendar.py",
+    "microsoft_calendar": "microsoft_calendar.py",
+    "memory": "memory.py",
+    "web_fetch": "web_fetch.py",
+    "shell": "shell.py",
+    "diff_writer": "diff_writer.py",
+    "todo_list": "todo_list.py",
+    "slash_command": "slash_command.py",
+}
+
+# Registry of copyable plugins
+PLUGINS = {
+    "re_act": "re_act.py",
+    "eval": "eval.py",
+    "image_result_formatter": "image_result_formatter.py",
+    "shell_approval": "shell_approval.py",
+    "gmail_plugin": "gmail_plugin.py",
+    "calendar_plugin": "calendar_plugin.py",
+}
+
+
+def handle_copy(
+    names: List[str],
+    list_all: bool = False,
+    path: Optional[str] = None,
+    force: bool = False
+):
+    """Copy built-in tools and plugins to user's project."""
+
+    # Show list if requested or no names provided
+    if list_all or not names:
+        show_available_items()
+        return
+
+    # Get source directories using import system (works for installed packages)
+    import connectonion.useful_tools as tools_module
+    import connectonion.useful_plugins as plugins_module
+
+    useful_tools_dir = Path(tools_module.__file__).parent
+    useful_plugins_dir = Path(plugins_module.__file__).parent
+
+    current_dir = Path.cwd()
+
+    for name in names:
+        name_lower = name.lower()
+
+        # Check if it's a tool
+        if name_lower in TOOLS:
+            source = useful_tools_dir / TOOLS[name_lower]
+            dest_dir = Path(path) if path else current_dir / "tools"
+            copy_file(source, dest_dir, force)
+
+        # Check if it's a plugin
+        elif name_lower in PLUGINS:
+            source = useful_plugins_dir / PLUGINS[name_lower]
+            dest_dir = Path(path) if path else current_dir / "plugins"
+            copy_file(source, dest_dir, force)
+
+        else:
+            console.print(f"[red]Unknown: {name}[/red]")
+            console.print("Use [cyan]co copy --list[/cyan] to see available items")
+
+
+def copy_file(source: Path, dest_dir: Path, force: bool):
+    """Copy a single file to destination."""
+    if not source.exists():
+        console.print(f"[red]Source not found: {source}[/red]")
+        return
+
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / source.name
+
+    if dest.exists() and not force:
+        console.print(f"[yellow]Skipped: {dest} (exists, use --force)[/yellow]")
+        return
+
+    shutil.copy2(source, dest)
+    console.print(f"[green]✓ Copied: {dest}[/green]")
+
+
+def show_available_items():
+    """Display available tools and plugins."""
+    table = Table(title="Available Items to Copy")
+    table.add_column("Name", style="cyan")
+    table.add_column("Type", style="green")
+    table.add_column("File")
+
+    for name, file in sorted(TOOLS.items()):
+        table.add_row(name, "tool", file)
+
+    for name, file in sorted(PLUGINS.items()):
+        table.add_row(name, "plugin", file)
+
+    console.print(table)
+    console.print("\n[dim]Usage: co copy <name> [--path ./custom/][/dim]")

{connectonion-0.5.7 → connectonion-0.5.9}/connectonion/cli/main.py

@@ -11,7 +11,7 @@ LLM-Note:
 
 import typer
 from rich.console import Console
-from typing import Optional
+from typing import Optional, List
 
 from .. import __version__
 
@@ -54,6 +54,7 @@ def _show_help():
     console.print("[bold]Commands:[/bold]")
     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]deploy[/green]            Deploy to ConnectOnion Cloud")
     console.print("  [green]auth[/green]              Authenticate for managed keys")
     console.print("  [green]status[/green]            Check account balance")
@@ -139,6 +140,18 @@ def browser(command: str = typer.Argument(..., help="Browser command")):
     handle_browser(command)
 
 
+@app.command()
+def copy(
+    names: List[str] = typer.Argument(None, help="Tool or plugin names to copy"),
+    list_all: bool = typer.Option(False, "--list", "-l", help="List available items"),
+    path: Optional[str] = typer.Option(None, "--path", "-p", help="Custom destination path"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing files"),
+):
+    """Copy built-in tools/plugins to customize."""
+    from .commands.copy_commands import handle_copy
+    handle_copy(names=names or [], list_all=list_all, path=path, force=force)
+
+
 def cli():
     """Entry point."""
     app()

connectonion-0.5.9/connectonion/connect.py

@@ -0,0 +1,272 @@
+"""
+Purpose: Client interface for connecting to remote agents via HTTP or relay network
+LLM-Note:
+  Dependencies: imports from [asyncio, json, uuid, time, aiohttp, websockets, address] | imported by [__init__.py, tests/test_connect.py, examples/] | tested by [tests/test_connect.py]
+  Data flow: connect(address, keys) → RemoteAgent → input() → discover endpoints → try HTTP first → fallback to relay → return result
+  State/Effects: caches discovered endpoint for reuse | optional signing with keys parameter
+  Integration: exposes connect(address, keys, relay_url), RemoteAgent class with .input(), .input_async()
+  Performance: discovery cached per RemoteAgent instance | HTTPS tried first (direct), relay as fallback
+
+Connect to remote agents on the network.
+
+Smart discovery: tries HTTP endpoints first, falls back to relay.
+Always signs requests when keys are provided.
+"""
+
+import asyncio
+import json
+import time
+import uuid
+from typing import Any, Dict, List, Optional
+
+from . import address as addr
+
+
+class RemoteAgent:
+    """
+    Interface to a remote agent.
+
+    Supports:
+    - Discovery via relay API
+    - Direct HTTP POST to agent /input endpoint
+    - WebSocket relay fallback
+    - Signed requests when keys provided
+    - Multi-turn conversations via session management
+
+    Usage:
+        # Standard Python scripts
+        agent = connect("0x...")
+        result = agent.input("Hello")
+
+        # Jupyter notebooks or async code
+        agent = connect("0x...")
+        result = await agent.input_async("Hello")
+    """
+
+    def __init__(
+        self,
+        agent_address: str,
+        *,
+        keys: Optional[Dict[str, Any]] = None,
+        relay_url: str = "wss://oo.openonion.ai/ws/announce"
+    ):
+        self.address = agent_address
+        self._keys = keys
+        self._relay_url = relay_url
+        self._cached_endpoint: Optional[str] = None
+        self._session: Optional[Dict[str, Any]] = None  # Multi-turn conversation state
+
+    def input(self, prompt: str, timeout: float = 30.0) -> str:
+        """
+        Send task to remote agent and get response (sync version).
+
+        Automatically maintains conversation context across calls.
+
+        Note:
+            This method cannot be used inside an async context (e.g., Jupyter notebooks,
+            async functions). Use input_async() instead in those environments.
+
+        Args:
+            prompt: Task/prompt to send
+            timeout: Seconds to wait for response (default 30)
+
+        Returns:
+            Agent's response string
+
+        Raises:
+            RuntimeError: If called from within a running event loop
+
+        Example:
+            >>> translator = connect("0x3d40...")
+            >>> result = translator.input("Translate 'hello' to Spanish")
+            >>> # Continue conversation
+            >>> result2 = translator.input("Now translate it to French")
+        """
+        try:
+            asyncio.get_running_loop()
+            raise RuntimeError(
+                "input() cannot be used inside async context (e.g., Jupyter notebooks). "
+                "Use 'await agent.input_async()' instead."
+            )
+        except RuntimeError as e:
+            if "input() cannot be used" in str(e):
+                raise
+            # No running loop - safe to proceed
+        return asyncio.run(self._send_task(prompt, timeout))
+
+    async def input_async(self, prompt: str, timeout: float = 30.0) -> str:
+        """
+        Send task to remote agent and get response (async version).
+
+        Automatically maintains conversation context across calls.
+
+        Args:
+            prompt: Task/prompt to send
+            timeout: Seconds to wait for response (default 30)
+
+        Returns:
+            Agent's response string
+        """
+        return await self._send_task(prompt, timeout)
+
+    def reset_conversation(self):
+        """Clear conversation history and start fresh."""
+        self._session = None
+
+    def _sign_payload(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Sign a payload if keys are available."""
+        if not self._keys:
+            return {"prompt": payload.get("prompt", "")}
+
+        canonical = json.dumps(payload, sort_keys=True, separators=(',', ':'))
+        signature = addr.sign(self._keys, canonical.encode())
+        return {
+            "payload": payload,
+            "from": self._keys["address"],
+            "signature": signature.hex()
+        }
+
+    async def _discover_endpoints(self) -> List[str]:
+        """Query relay API for agent endpoints."""
+        import aiohttp
+
+        # Convert wss://oo.openonion.ai/ws/announce to https://oo.openonion.ai
+        base_url = self._relay_url.replace("wss://", "https://").replace("ws://", "http://")
+        base_url = base_url.replace("/ws/announce", "")
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{base_url}/api/relay/agents/{self.address}") as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    if data.get("online"):
+                        return data.get("endpoints", [])
+        return []
+
+    def _create_signed_body(self, prompt: str) -> Dict[str, Any]:
+        """Create signed request body for agent /input endpoint."""
+        payload = {"prompt": prompt, "to": self.address, "timestamp": int(time.time())}
+        body = self._sign_payload(payload)
+        if self._session:
+            body["session"] = self._session
+        return body
+
+    async def _send_http(self, endpoint: str, prompt: str, timeout: float) -> str:
+        """Send request via direct HTTP POST to agent /input endpoint."""
+        import aiohttp
+
+        body = self._create_signed_body(prompt)
+
+        async with aiohttp.ClientSession() as http_session:
+            async with http_session.post(
+                f"{endpoint}/input",
+                json=body,
+                timeout=aiohttp.ClientTimeout(total=timeout)
+            ) as resp:
+                data = await resp.json()
+                if not resp.ok:
+                    raise ConnectionError(data.get("error", f"HTTP {resp.status}"))
+                # Save session for conversation continuation
+                if "session" in data:
+                    self._session = data["session"]
+                return data.get("result", "")
+
+    async def _send_relay(self, prompt: str, timeout: float) -> str:
+        """Send request via WebSocket relay."""
+        import websockets
+
+        input_id = str(uuid.uuid4())
+        relay_input_url = self._relay_url.replace("/ws/announce", "/ws/input")
+
+        async with websockets.connect(relay_input_url) as ws:
+            payload = {"prompt": prompt, "to": self.address, "timestamp": int(time.time())}
+            signed = self._sign_payload(payload)
+
+            input_message = {
+                "type": "INPUT",
+                "input_id": input_id,
+                "to": self.address,
+                **signed
+            }
+
+            await ws.send(json.dumps(input_message))
+
+            response_data = await asyncio.wait_for(ws.recv(), timeout=timeout)
+            response = json.loads(response_data)
+
+            if response.get("type") == "OUTPUT" and response.get("input_id") == input_id:
+                return response.get("result", "")
+            elif response.get("type") == "ERROR":
+                raise ConnectionError(f"Agent error: {response.get('error')}")
+            else:
+                raise ConnectionError(f"Unexpected response: {response}")
+
+    async def _send_task(self, prompt: str, timeout: float) -> str:
+        """
+        Send task using best available connection method.
+
+        Priority:
+        1. Cached endpoint (if previously successful)
+        2. Discovered HTTPS endpoints
+        3. Discovered HTTP endpoints
+        4. Relay fallback
+        """
+        # Try cached endpoint first
+        if self._cached_endpoint:
+            try:
+                return await self._send_http(self._cached_endpoint, prompt, timeout)
+            except Exception:
+                self._cached_endpoint = None  # Clear failed cache
+
+        # Discover endpoints
+        endpoints = await self._discover_endpoints()
+
+        # Sort: HTTPS first, then HTTP
+        endpoints.sort(key=lambda e: (0 if e.startswith("https://") else 1))
+
+        # Try each endpoint
+        for endpoint in endpoints:
+            try:
+                result = await self._send_http(endpoint, prompt, timeout)
+                self._cached_endpoint = endpoint  # Cache successful endpoint
+                return result
+            except Exception:
+                continue
+
+        # Fallback to relay
+        return await self._send_relay(prompt, timeout)
+
+    def __repr__(self):
+        short = self.address[:12] + "..." if len(self.address) > 12 else self.address
+        return f"RemoteAgent({short})"
+
+
+def connect(
+    address: str,
+    *,
+    keys: Optional[Dict[str, Any]] = None,
+    relay_url: str = "wss://oo.openonion.ai/ws/announce"
+) -> RemoteAgent:
+    """
+    Connect to a remote agent.
+
+    Args:
+        address: Agent's public key address (0x...)
+        keys: Signing keys from address.load() - required for strict trust agents
+        relay_url: Relay server URL (default: production)
+
+    Returns:
+        RemoteAgent interface
+
+    Example:
+        >>> from connectonion import connect, address
+        >>>
+        >>> # Simple (unsigned)
+        >>> agent = connect("0x3d4017c3...")
+        >>> result = agent.input("Hello")
+        >>>
+        >>> # With signing (for strict trust agents)
+        >>> keys = address.load(Path(".co"))
+        >>> agent = connect("0x3d4017c3...", keys=keys)
+        >>> result = agent.input("Hello")
+    """
+    return RemoteAgent(address, keys=keys, relay_url=relay_url)

{connectonion-0.5.7 → connectonion-0.5.9}/connectonion/host.py

@@ -368,7 +368,12 @@ def admin_logs_handler(agent_name: str) -> dict:
 
 
 def admin_sessions_handler() -> dict:
-    """GET /admin/sessions - return all activity sessions as JSON array."""
+    """GET /admin/sessions - return raw session YAML files as JSON.
+
+    Returns session files as-is (converted from YAML to JSON). Each session
+    contains: name, created, updated, total_cost, total_tokens, turns array.
+    Frontend handles the display logic.
+    """
     import yaml
     sessions_dir = Path(".co/sessions")
     if not sessions_dir.exists():
@@ -381,8 +386,8 @@ def admin_sessions_handler() -> dict:
             if session_data:
                 sessions.append(session_data)
 
-    # Sort by created date descending (newest first)
-    sessions.sort(key=lambda s: s.get("created", ""), reverse=True)
+    # Sort by updated date descending (newest first)
+    sessions.sort(key=lambda s: s.get("updated", s.get("created", "")), reverse=True)
     return {"sessions": sessions}
 
 

{connectonion-0.5.7 → connectonion-0.5.9}/connectonion/static/docs.html

@@ -366,6 +366,70 @@
       </div>
     </details>
 
+    <!-- Admin Endpoints Header -->
+    <div style="margin:24px 0 12px;padding:12px 16px;background:var(--panel);border:1px solid var(--panel-border);border-radius:4px;">
+      <div class="row between">
+        <div>
+          <h3 style="margin:0;font-size:14px;">Admin Endpoints</h3>
+          <p style="margin:4px 0 0;font-size:12px;color:var(--muted);">Requires OPENONION_API_KEY authorization</p>
+        </div>
+        <div class="row" style="gap:8px;">
+          <label for="api-key" style="font-size:12px;margin:0;">API Key:</label>
+          <input type="password" id="api-key" placeholder="Enter API key..." style="width:200px;height:36px;font-size:12px;" />
+        </div>
+      </div>
+    </div>
+
+    <!-- GET /admin/logs -->
+    <details class="endpoint">
+      <summary class="endpoint-header">
+        <span class="method get">GET</span>
+        <span class="endpoint-path">/admin/logs</span>
+        <span class="endpoint-desc">Get agent activity logs (auth required)</span>
+        <span class="endpoint-expand">▾</span>
+      </summary>
+      <div class="endpoint-body">
+        <button class="btn execute" onclick="fetchAdminLogs()">Execute</button>
+        <div class="endpoint-section" style="margin-top:12px;">
+          <h4>Curl</h4>
+          <div class="curl-box">
+            <pre id="admin-logs-curl">curl -X GET "http://localhost:8000/admin/logs" \
+  -H "Authorization: Bearer YOUR_API_KEY"</pre>
+            <button class="copy-btn" onclick="copyCurl('admin-logs-curl')">Copy</button>
+          </div>
+        </div>
+        <div class="endpoint-section">
+          <h4>Response</h4>
+          <pre id="admin-logs-result" style="max-height:400px;">{ }</pre>
+        </div>
+      </div>
+    </details>
+
+    <!-- GET /admin/sessions -->
+    <details class="endpoint">
+      <summary class="endpoint-header">
+        <span class="method get">GET</span>
+        <span class="endpoint-path">/admin/sessions</span>
+        <span class="endpoint-desc">Get all activity sessions (auth required)</span>
+        <span class="endpoint-expand">▾</span>
+      </summary>
+      <div class="endpoint-body">
+        <button class="btn execute" onclick="fetchAdminSessions()">Execute</button>
+        <div class="endpoint-section" style="margin-top:12px;">
+          <h4>Curl</h4>
+          <div class="curl-box">
+            <pre id="admin-sessions-curl">curl -X GET "http://localhost:8000/admin/sessions" \
+  -H "Authorization: Bearer YOUR_API_KEY"</pre>
+            <button class="copy-btn" onclick="copyCurl('admin-sessions-curl')">Copy</button>
+          </div>
+        </div>
+        <div class="endpoint-section">
+          <h4>Response</h4>
+          <pre id="admin-sessions-result" style="max-height:400px;">{ }</pre>
+        </div>
+      </div>
+    </details>
+
     <!-- WebSocket /ws -->
     <details class="endpoint">
       <summary class="endpoint-header">
@@ -580,6 +644,39 @@
       loadInfo(); refreshSessions();
     }
 
+    async function fetchAdminLogs(){
+      const apiKey = $('api-key').value.trim();
+      if (!apiKey) {
+        $('admin-logs-result').textContent = '{"error": "Please enter API key"}';
+        return;
+      }
+      $('admin-logs-result').textContent = 'Loading...';
+      const res = await fetch(buildUrl('/admin/logs'), {
+        headers: { 'Authorization': 'Bearer ' + apiKey }
+      });
+      if (res.ok) {
+        const text = await res.text();
+        $('admin-logs-result').textContent = text || '(empty)';
+      } else {
+        const data = await res.json().catch(() => ({ error: res.statusText }));
+        $('admin-logs-result').textContent = JSON.stringify(data, null, 2);
+      }
+    }
+
+    async function fetchAdminSessions(){
+      const apiKey = $('api-key').value.trim();
+      if (!apiKey) {
+        $('admin-sessions-result').textContent = '{"error": "Please enter API key"}';
+        return;
+      }
+      $('admin-sessions-result').textContent = 'Loading...';
+      const res = await fetch(buildUrl('/admin/sessions'), {
+        headers: { 'Authorization': 'Bearer ' + apiKey }
+      });
+      const data = await res.json();
+      $('admin-sessions-result').textContent = JSON.stringify(data, null, 2);
+    }
+
     $('prompt').addEventListener('input', updatePayloadPreview);
     $('from').addEventListener('input', updateCurlCommands);
     $('signature').addEventListener('input', updateCurlCommands);