connectonion 0.5.8__tar.gz → 0.5.10__tar.gz

{connectonion-0.5.8 → connectonion-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: connectonion
-Version: 0.5.8
+Version: 0.5.10
 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.8 → connectonion-0.5.10}/connectonion/__init__.py

@@ -1,6 +1,6 @@
 """ConnectOnion - A simple agent framework with behavior tracking."""
 
-__version__ = "0.5.8"
+__version__ = "0.5.10"
 
 # 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.10/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.8 → connectonion-0.5.10}/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.10/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.8 → connectonion-0.5.10}/connectonion/host.py

@@ -9,7 +9,13 @@ Trust parameter accepts three forms:
 3. Agent: Custom Agent instance for verification
 
 All forms create a trust agent behind the scenes.
+
+Worker Isolation:
+Each request gets a fresh deep copy of the agent template.
+This ensures complete isolation - tools with state (like BrowserTool)
+don't interfere between concurrent requests.
 """
+import copy
 import hashlib
 import json
 import logging
@@ -102,17 +108,18 @@ class SessionStorage:
 
 # === Handlers (pure functions) ===
 
-def input_handler(agent, storage: SessionStorage, prompt: str, result_ttl: int,
+def input_handler(agent_template, storage: SessionStorage, prompt: str, result_ttl: int,
                   session: dict | None = None) -> dict:
     """POST /input
 
     Args:
-        agent: The agent to process the request
+        agent_template: The agent template (deep copied per request for isolation)
         storage: SessionStorage for persisting results
         prompt: The user's prompt
         result_ttl: How long to keep the result on server
         session: Optional conversation session for continuation
     """
+    agent = copy.deepcopy(agent_template)
     now = time.time()
 
     # Get or generate session_id
@@ -368,7 +375,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,30 +393,34 @@ 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}
 
 
 # === Entry Point ===
 
-def _create_handlers(agent, result_ttl: int):
+def _create_handlers(agent_template, result_ttl: int):
     """Create handler dict for ASGI app."""
+    def ws_input(prompt: str) -> str:
+        agent = copy.deepcopy(agent_template)
+        return agent.input(prompt)
+
     return {
-        "input": lambda storage, prompt, ttl, session=None: input_handler(agent, storage, prompt, ttl, session),
+        "input": lambda storage, prompt, ttl, session=None: input_handler(agent_template, storage, prompt, ttl, session),
         "session": session_handler,
         "sessions": sessions_handler,
-        "health": lambda start_time: health_handler(agent, start_time),
-        "info": lambda trust: info_handler(agent, trust),
+        "health": lambda start_time: health_handler(agent_template, start_time),
+        "info": lambda trust: info_handler(agent_template, trust),
         "auth": extract_and_authenticate,
-        "ws_input": agent.input,
+        "ws_input": ws_input,
         # Admin endpoints (auth required via OPENONION_API_KEY)
-        "admin_logs": lambda: admin_logs_handler(agent.name),
+        "admin_logs": lambda: admin_logs_handler(agent_template.name),
         "admin_sessions": admin_sessions_handler,
     }
 
 
-def _start_relay_background(agent, relay_url: str, addr_data: dict):
+def _start_relay_background(agent_template, relay_url: str, addr_data: dict):
     """Start relay connection in background thread.
 
     The relay connection runs alongside the HTTP server, allowing the agent
@@ -415,11 +431,12 @@ def _start_relay_background(agent, relay_url: str, addr_data: dict):
     from . import announce, relay
 
     # Create ANNOUNCE message
-    summary = agent.system_prompt[:1000] if agent.system_prompt else f"{agent.name} agent"
+    summary = agent_template.system_prompt[:1000] if agent_template.system_prompt else f"{agent_template.name} agent"
     announce_msg = announce.create_announce_message(addr_data, summary, endpoints=[])
 
-    # Task handler that routes to agent.input()
+    # Task handler - deep copy for each request
     async def task_handler(prompt: str) -> str:
+        agent = copy.deepcopy(agent_template)
         return agent.input(prompt)
 
     async def relay_loop():