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

connectonion/{asgi.py → network/asgi.py}

@@ -6,13 +6,48 @@ requests. Separated from host.py for better testing and smaller file size.
 Design decision: Raw ASGI instead of Starlette/FastAPI for full protocol control.
 See: docs/design-decisions/022-raw-asgi-implementation.md
 """
+import asyncio
 import hmac
 import json
 import os
+import queue
+import threading
 from pathlib import Path
+from typing import Any, Dict
 
 from pydantic import BaseModel
 
+from .connection import Connection
+
+
+class AsyncToSyncConnection(Connection):
+    """Bridge async WebSocket to sync Connection interface.
+
+    Uses queues to communicate between async WebSocket handler and sync agent code.
+    The agent runs in a thread, sending/receiving via queues.
+    The async handler pumps messages between WebSocket and queues.
+    """
+
+    def __init__(self):
+        self._outgoing: queue.Queue[Dict[str, Any]] = queue.Queue()
+        self._incoming: queue.Queue[Dict[str, Any]] = queue.Queue()
+        self._closed = False
+
+    def send(self, event: Dict[str, Any]) -> None:
+        """Queue event to be sent to client."""
+        if not self._closed:
+            self._outgoing.put(event)
+
+    def receive(self) -> Dict[str, Any]:
+        """Block until response from client."""
+        return self._incoming.get()
+
+    def close(self):
+        """Mark connection as closed."""
+        self._closed = True
+        # Unblock any waiting receive
+        self._incoming.put({"type": "connection_closed"})
+
 
 def _json_default(obj):
     """Handle non-serializable objects like Pydantic models.
@@ -190,6 +225,11 @@ async def handle_websocket(
 ):
     """Handle WebSocket connections at /ws.
 
+    Supports bidirectional communication via Connection interface:
+    - Agent sends events via connection.log() / connection.send()
+    - Agent requests approval via connection.request_approval()
+    - Client responds to approval requests
+
     Args:
         scope: ASGI scope dict
         receive: ASGI receive callable
@@ -229,9 +269,89 @@ async def handle_websocket(
                     await send({"type": "websocket.send",
                                "text": json.dumps({"type": "ERROR", "message": "prompt required"})})
                     continue
-                result = handlers["ws_input"](prompt)
+
+                # Create connection for bidirectional communication
+                connection = AsyncToSyncConnection()
+                agent_done = threading.Event()
+                result_holder = [None]
+
+                def run_agent():
+                    result_holder[0] = handlers["ws_input"](prompt, connection)
+                    agent_done.set()
+
+                # Start agent in thread
+                agent_thread = threading.Thread(target=run_agent, daemon=True)
+                agent_thread.start()
+
+                # Pump messages between WebSocket and connection
+                await _pump_messages(receive, send, connection, agent_done)
+
+                # Send final result
                 await send({"type": "websocket.send",
-                           "text": json.dumps({"type": "OUTPUT", "result": result})})
+                           "text": json.dumps({"type": "OUTPUT", "result": result_holder[0]})})
+
+
+async def _pump_messages(ws_receive, ws_send, connection: AsyncToSyncConnection, agent_done: threading.Event):
+    """Pump messages between WebSocket and connection queues.
+
+    Runs until agent completes. Handles:
+    - Outgoing: connection._outgoing queue → WebSocket
+    - Incoming: WebSocket → connection._incoming queue (for approval responses)
+    """
+    loop = asyncio.get_event_loop()
+
+    async def send_outgoing():
+        """Send outgoing messages from connection to WebSocket."""
+        while not agent_done.is_set():
+            # Use run_in_executor for blocking queue.get
+            try:
+                event = await loop.run_in_executor(
+                    None, lambda: connection._outgoing.get(timeout=0.05)
+                )
+                await ws_send({"type": "websocket.send", "text": json.dumps(event)})
+            except queue.Empty:
+                pass
+
+        # Drain remaining
+        while True:
+            try:
+                event = connection._outgoing.get_nowait()
+                await ws_send({"type": "websocket.send", "text": json.dumps(event)})
+            except queue.Empty:
+                break
+
+    async def receive_incoming():
+        """Receive incoming messages from WebSocket to connection."""
+        while not agent_done.is_set():
+            try:
+                msg = await asyncio.wait_for(ws_receive(), timeout=0.1)
+                if msg["type"] == "websocket.receive":
+                    try:
+                        data = json.loads(msg.get("text", "{}"))
+                        connection._incoming.put(data)
+                    except json.JSONDecodeError:
+                        pass
+                elif msg["type"] == "websocket.disconnect":
+                    connection.close()
+                    break
+            except asyncio.TimeoutError:
+                continue
+
+    # Run both tasks concurrently
+    send_task = asyncio.create_task(send_outgoing())
+    recv_task = asyncio.create_task(receive_incoming())
+
+    # Wait for agent to complete
+    while not agent_done.is_set():
+        await asyncio.sleep(0.05)
+
+    # Cancel receive task and wait for send to finish draining
+    recv_task.cancel()
+    try:
+        await recv_task
+    except asyncio.CancelledError:
+        pass
+    await send_task
 
 
 def create_app(

connectonion/{connect.py → network/connect.py}

@@ -19,7 +19,7 @@ import time
 import uuid
 from typing import Any, Dict, List, Optional
 
-from . import address as addr
+from .. import address as addr
 
 
 class RemoteAgent:

connectonion/network/connection.py

@@ -0,0 +1,123 @@
+"""
+Purpose: Connection interface for agent-client communication during hosted execution
+LLM-Note:
+  Dependencies: imports from [abc, typing] | imported by [asgi.py, __init__.py] | tested by [tests/unit/test_connection.py]
+  Data flow: receives from host/asgi → WebSocket send/receive → provides log() and request_approval() to agent event handlers
+  State/Effects: stateless base class | WebSocketConnection wraps ASGI WebSocket for bidirectional messaging
+  Integration: exposes Connection (base), WebSocketConnection (ASGI adapter) | agent.connection set by host() during WebSocket requests
+  Performance: log() is fire-and-forget (non-blocking) | request_approval() blocks waiting for client response
+  Errors: WebSocketConnection raises if WebSocket closed unexpectedly
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+
+class Connection(ABC):
+    """Base connection interface for agent-client communication.
+
+    Two-layer API:
+    - Low-level: send(event), receive() - primitives for any communication
+    - High-level: log(type, **data), request_approval(tool, args) - common patterns
+
+    Usage in event handlers:
+        @after_llm
+        def on_thinking(agent):
+            if agent.connection:
+                agent.connection.log("thinking")
+
+        @before_each_tool
+        def on_tool(agent):
+            if agent.connection:
+                tool = agent.current_session['pending_tool']
+                if tool['name'] in DANGEROUS:
+                    if not agent.connection.request_approval(tool['name'], tool['arguments']):
+                        raise ToolRejected()
+    """
+
+    # ═══════════════════════════════════════════════════════
+    # LOW-LEVEL API (Primitives)
+    # ═══════════════════════════════════════════════════════
+
+    @abstractmethod
+    def send(self, event: Dict[str, Any]) -> None:
+        """Send any event to client.
+
+        Args:
+            event: Dict with at least 'type' key, e.g. {"type": "thinking"}
+        """
+        pass
+
+    @abstractmethod
+    def receive(self) -> Dict[str, Any]:
+        """Receive response from client.
+
+        Returns:
+            Dict response from client
+        """
+        pass
+
+    # ═══════════════════════════════════════════════════════
+    # HIGH-LEVEL API (Patterns)
+    # ═══════════════════════════════════════════════════════
+
+    def log(self, event_type: str, **data) -> None:
+        """One-way notification to client.
+
+        Common event types: thinking, tool_call, tool_result, complete, error
+
+        Args:
+            event_type: Type of event (e.g. "thinking", "tool_call")
+            **data: Additional data for the event
+
+        Example:
+            connection.log("thinking")
+            connection.log("tool_call", name="search", arguments={"q": "python"})
+        """
+        self.send({"type": event_type, **data})
+
+    def request_approval(self, tool: str, arguments: Dict[str, Any]) -> bool:
+        """Two-way: request permission, wait for response.
+
+        Sends approval_needed event and blocks until client responds.
+
+        Args:
+            tool: Name of tool requiring approval
+            arguments: Tool arguments to show user
+
+        Returns:
+            True if approved, False if rejected
+
+        Example:
+            if not connection.request_approval("delete_file", {"path": "/tmp/x"}):
+                raise ToolRejected()
+        """
+        self.send({"type": "approval_needed", "tool": tool, "arguments": arguments})
+        response = self.receive()
+        return response.get("approved", False)
+
+
+class SyncWebSocketConnection(Connection):
+    """Synchronous WebSocket connection adapter.
+
+    Wraps async WebSocket send/receive for use in synchronous agent code.
+    Uses threading events to bridge async/sync boundary.
+    """
+
+    def __init__(self, send_callback, receive_callback):
+        """Initialize with send/receive callbacks.
+
+        Args:
+            send_callback: Callable that sends message to WebSocket
+            receive_callback: Callable that receives message from WebSocket
+        """
+        self._send = send_callback
+        self._receive = receive_callback
+
+    def send(self, event: Dict[str, Any]) -> None:
+        """Send event to client via WebSocket."""
+        self._send(event)
+
+    def receive(self) -> Dict[str, Any]:
+        """Receive response from client via WebSocket."""
+        return self._receive()

connectonion/{host.py → network/host.py}

@@ -177,8 +177,8 @@ def health_handler(agent, start_time: float) -> dict:
 
 def info_handler(agent, trust: str) -> dict:
     """GET /info"""
-    from . import __version__
-    tools = agent.tools.list_names() if hasattr(agent.tools, "list_names") else []
+    from .. import __version__
+    tools = agent.tools.names() if hasattr(agent.tools, "names") else []
     return {
         "name": agent.name,
         "address": get_agent_address(agent),
@@ -338,7 +338,7 @@ def evaluate_with_trust_agent(trust_agent, prompt: str, identity: str, sig_valid
         (accepted, reason) tuple
     """
     from pydantic import BaseModel
-    from .llm_do import llm_do
+    from ..llm_do import llm_do
 
     class TrustDecision(BaseModel):
         accept: bool
@@ -382,7 +382,7 @@ def admin_sessions_handler() -> dict:
     Frontend handles the display logic.
     """
     import yaml
-    sessions_dir = Path(".co/sessions")
+    sessions_dir = Path(".co/evals")
     if not sessions_dir.exists():
         return {"sessions": []}
 
@@ -401,10 +401,17 @@ def admin_sessions_handler() -> dict:
 # === Entry Point ===
 
 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)
+    """Create handler dict for ASGI app.
+
+    Args:
+        agent_template: Agent used as template (deep-copied per request for isolation)
+        result_ttl: How long to keep results on server in seconds
+    """
+    def ws_input(prompt: str, connection) -> str:
+        """WebSocket input with bidirectional connection support."""
+        agent_template.reset_conversation()
+        agent_template.connection = connection
+        return agent_template.input(prompt)
 
     return {
         "input": lambda storage, prompt, ttl, session=None: input_handler(agent_template, storage, prompt, ttl, session),
@@ -425,6 +432,11 @@ def _start_relay_background(agent_template, relay_url: str, addr_data: dict):
 
     The relay connection runs alongside the HTTP server, allowing the agent
     to be discovered via P2P network while also serving HTTP requests.
+
+    Args:
+        agent_template: Agent used as template (deep-copied per request for isolation)
+        relay_url: WebSocket URL for P2P relay
+        addr_data: Agent address data (public key, address)
     """
     import asyncio
     import threading
@@ -466,8 +478,12 @@ def host(
     """
     Host an agent over HTTP/WebSocket with optional P2P relay discovery.
 
+    The agent is used as a template - each request gets a fresh deep copy
+    for complete isolation. This ensures tools with state (like BrowserTool)
+    don't interfere between concurrent requests.
+
     Args:
-        agent: Agent to host
+        agent: Agent template (deep-copied per request for isolation)
         port: HTTP port (default: PORT env var or 8000)
         trust: Trust level, policy, or Agent:
             - Level: "open", "careful", "strict"
@@ -492,7 +508,7 @@ def host(
         GET  /logs/sessions - Activity sessions (requires OPENONION_API_KEY)
     """
     import uvicorn
-    from . import address
+    from .. import address
 
     # Use PORT env var if port not specified (for container deployments)
     if port is None:
@@ -543,8 +559,11 @@ def host(
 def _make_app(agent, trust: Union[str, "Agent"] = "careful", result_ttl=86400, *, blacklist=None, whitelist=None):
     """Create ASGI app for external uvicorn/gunicorn usage.
 
+    The agent is used as a template - each request gets a fresh deep copy
+    for complete isolation.
+
     Args:
-        agent: Agent to host
+        agent: Agent template (deep-copied per request for isolation)
         trust: Trust level, policy, or Agent
         result_ttl: How long to keep results on server in seconds
         blacklist: Blocked identities
@@ -579,6 +598,7 @@ host.app = _make_app
 def create_app_compat(agent, storage, trust="careful", result_ttl=86400, *, blacklist=None, whitelist=None):
     """Create ASGI app (backward-compatible wrapper).
 
+    The agent is used as a template (deep-copied per request for isolation).
     Prefer using host.app(agent) for new code.
     """
     handlers = _create_handlers(agent, result_ttl)

connectonion/{trust.py → network/trust.py}

@@ -59,7 +59,7 @@ def create_trust_agent(trust: Union[str, Path, 'Agent', None], api_key: Optional
         ValueError: If trust level is invalid
         FileNotFoundError: If trust policy file doesn't exist
     """
-    from .agent import Agent  # Import here to avoid circular dependency
+    from ..core.agent import Agent  # Import here to avoid circular dependency
     
     # If None, check for environment default
     if trust is None:

connectonion/tui/__init__.py

@@ -37,8 +37,20 @@ from .status_bar import StatusBar, SimpleStatusBar, ProgressSegment
 from .divider import Divider
 from .pick import pick
 from .footer import Footer
+from .chat import (
+    Chat,
+    TriggerAutoComplete,
+    ChatStatusBar,
+    HintsFooter,
+    WelcomeMessage,
+    UserMessage,
+    AssistantMessage,
+    ThinkingIndicator,
+)
+from textual_autocomplete import DropdownItem as CommandItem
 
 __all__ = [
+    # Rich-based TUI (legacy)
     "Input",
     "Dropdown",
     "DropdownItem",
@@ -54,4 +66,14 @@ __all__ = [
     "Divider",
     "pick",
     "Footer",
+    # Textual-based Chat
+    "Chat",
+    "TriggerAutoComplete",
+    "CommandItem",
+    "ChatStatusBar",
+    "HintsFooter",
+    "WelcomeMessage",
+    "UserMessage",
+    "AssistantMessage",
+    "ThinkingIndicator",
 ]