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

connectonion/{host.py → network/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
@@ -170,7 +177,7 @@ def health_handler(agent, start_time: float) -> dict:
 
 def info_handler(agent, trust: str) -> dict:
     """GET /info"""
-    from . import __version__
+    from .. import __version__
     tools = agent.tools.list_names() if hasattr(agent.tools, "list_names") else []
     return {
         "name": agent.name,
@@ -331,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
@@ -393,38 +400,53 @@ def admin_sessions_handler() -> dict:
 
 # === Entry Point ===
 
-def _create_handlers(agent, result_ttl: int):
-    """Create handler dict for ASGI app."""
+def _create_handlers(agent_template, result_ttl: int):
+    """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) -> 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
     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
     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():
@@ -454,8 +476,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"
@@ -480,7 +506,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:
@@ -531,8 +557,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
@@ -567,6 +596,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",
 ]