connectonion 0.6.4__tar.gz → 0.6.5__tar.gz

{connectonion-0.6.4 → connectonion-0.6.5}/PKG-INFO

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

@@ -10,7 +10,7 @@ LLM-Note:
 ConnectOnion - A simple agent framework with behavior tracking.
 """
 
-__version__ = "0.6.4"
+__version__ = "0.6.5"
 
 # Auto-load .env files for the entire framework
 from dotenv import load_dotenv

{connectonion-0.6.4 → connectonion-0.6.5}/connectonion/cli/co_ai/main.py

@@ -47,6 +47,6 @@ def start_server(
             web_mode=True,
         )
 
-    # Start server with open trust (no auth required)
+    # Start server with careful trust (requires invite code or payment for strangers)
     # relay_url=None disables P2P discovery
-    host(agent_factory, port=port, trust="open", relay_url=None)
+    host(agent_factory, port=port, trust="careful", relay_url=None)

connectonion-0.6.5/connectonion/cli/co_ai/prompts/connectonion/concepts/trust.md

@@ -0,0 +1,249 @@
+# Trust in ConnectOnion
+
+Trust is a **host layer** concern that controls who can access your agent. It manages onboarding, access control, and client state transitions.
+
+## Quick Start
+
+```python
+from connectonion import Agent
+from connectonion.network import host
+
+# Create your agent (no trust here - agent only cares about its job)
+agent = Agent("my_service", tools=[process_data])
+
+# Host it with trust (trust is a host concern)
+host(agent, trust="careful")  # Default: verify before allowing access
+```
+
+## Core Concepts
+
+### Separation of Concerns
+
+| Layer | Responsibility |
+|-------|----------------|
+| **Agent** | What it does (skills, tools, reasoning) |
+| **Host** | How it's accessed (network, trust, security) |
+
+```python
+# Agent is pure - only cares about its job
+agent = Agent("translator", tools=[translate])
+
+# Trust is configured at host level
+host(agent, trust="open")     # Dev: trust everyone
+host(agent, trust="careful")  # Staging: verify first
+host(agent, trust="strict")   # Prod: whitelist only
+```
+
+### Two-Tier Verification
+
+| Type | Tokens | When to Use |
+|------|--------|-------------|
+| **Fast Rules** | Zero | Simple checks (invite code, payment, whitelist) |
+| **Trust Agent** | Burns tokens | Complex decisions (behavior analysis, edge cases) |
+
+90% of requests use fast rules (instant, free). 10% use trust agent (LLM reasoning, rare).
+
+## Trust Levels
+
+### Open (Development)
+
+Trust everyone. No verification.
+
+```python
+host(agent, trust="open")
+```
+
+Use for: Local development, Jupyter notebooks, testing.
+
+### Careful (Default)
+
+Verify strangers before granting access. Fast rules first, then trust agent for complex cases.
+
+```python
+host(agent, trust="careful")
+```
+
+Use for: Staging, testing, pre-production.
+
+### Strict (Production)
+
+Whitelist only. No exceptions.
+
+```python
+host(agent, trust="strict")
+```
+
+Use for: Production, sensitive data, payments.
+
+## Client States
+
+```
+Promotion Chain (earned trust):
+
+┌─────────────┐   verify    ┌─────────────┐  earn trust  ┌─────────────┐
+│  Stranger   │ ──────────► │   Contact   │ ───────────► │  Whitelist  │
+└─────────────┘             └─────────────┘              └─────────────┘
+      │                           │                            │
+      │ block                     │ demote                     │ demote
+      ▼                           ▼                            ▼
+┌─────────────┐             ┌─────────────┐              ┌─────────────┐
+│  Blocklist  │             │  Stranger   │              │   Contact   │
+└─────────────┘             └─────────────┘              └─────────────┘
+
+
+Admin (separate, manual only):
+
+┌─────────────┐  set_admin()   ┌─────────────┐
+│  Any Level  │ ─────────────► │    Admin    │
+└─────────────┘                └─────────────┘
+                                     │
+                               remove_admin()
+                                     │
+                                     ▼
+                               ┌─────────────┐
+                               │  Previous   │
+                               └─────────────┘
+```
+
+### Client Levels
+
+| Level | Description | Access |
+|-------|-------------|--------|
+| **Stranger** | Unknown client, not verified | Limited or none |
+| **Contact** | Verified via invite/payment | Standard access |
+| **Whitelist** | Trusted, pre-approved | Full access |
+| **Admin** | Can manage other clients | Full access + management |
+| **Blocklist** | Blocked, denied access | No access |
+
+## Trust Policy Files
+
+Trust policies are markdown files with YAML frontmatter. YAML defines fast rules (no tokens), markdown body defines trust agent behavior (for complex decisions).
+
+```yaml
+# prompts/trust/careful.md
+---
+fast_rules:
+  - if: has_invite_code
+    action: verify_invite
+    on_success: promote_to_contact
+
+  - if: is_blocked
+    action: deny
+
+  - if: is_whitelist
+    action: allow
+
+  - if: is_stranger
+    action: deny
+
+use_agent:
+  - when: requests > 10
+    reason: "Evaluate for promotion"
+
+cache: 24h
+---
+
+# Trust Agent Policy
+
+You handle complex trust decisions.
+
+## Available Tools
+- promote_to_contact(client_id)
+- block(client_id, reason)
+
+## When to Promote
+Promote stranger to contact when:
+- 10+ requests with good behavior
+- No suspicious patterns
+```
+
+## Atomic Functions
+
+Trust manager provides simple atomic functions as tools:
+
+```python
+# Promotion (earned)
+promote_to_contact(client_id)    # Stranger → Contact
+promote_to_whitelist(client_id)  # Contact → Whitelist
+
+# Demotion
+demote_to_contact(client_id)     # Whitelist → Contact
+demote_to_stranger(client_id)    # Contact → Stranger
+
+# Blocking
+block(client_id, reason)
+unblock(client_id)
+
+# Admin (manual only)
+set_admin(client_id, by_admin)
+remove_admin(client_id, by_admin)
+```
+
+## Custom Trust Policies
+
+### Option 1: Use Preset
+
+```python
+host(agent, trust="careful")  # Uses prompts/trust/careful.md
+```
+
+### Option 2: Custom Markdown File
+
+```python
+host(agent, trust="./my_policy.md")
+```
+
+### Option 3: Custom TrustAgent
+
+```python
+from connectonion.network.trust import TrustAgent
+
+trust = TrustAgent(
+    system_prompt="./my_policy.md",
+    tools=[my_custom_verifier]
+)
+host(agent, trust=trust)
+```
+
+## Environment-Based Defaults
+
+```python
+# No trust specified - auto-detected from environment
+host(agent)
+
+# CONNECTONION_ENV=development → trust="open"
+# CONNECTONION_ENV=staging     → trust="careful"
+# CONNECTONION_ENV=production  → trust="strict"
+```
+
+## List Management
+
+Trust manager maintains lists at `~/.co/`:
+
+```
+~/.co/
+├── contacts.txt     # Verified contacts
+├── whitelist.txt    # Trusted, pre-approved
+├── admins.txt       # Can manage other clients
+└── blocklist.txt    # Blocked clients
+```
+
+## FAQ
+
+**Q: What's the default trust level?**
+A: `"careful"` - verify strangers, allow contacts.
+
+**Q: Do fast rules burn tokens?**
+A: No. Fast rules are simple if/then executed by host. Zero tokens.
+
+**Q: When does trust agent run?**
+A: Only when `use_agent` triggers fire (e.g., after 10 requests). Rare.
+
+**Q: Can I use the same agent with different trust levels?**
+A: Yes. Trust is host config, not agent config.
+
+```python
+# Same agent, different trust
+host(agent, trust="open")    # Dev
+host(agent, trust="strict")  # Prod
+```

{connectonion-0.6.4 → connectonion-0.6.5}/connectonion/cli/commands/copy_commands.py

@@ -63,6 +63,13 @@ PROMPTS = {
     "coding_agent": "coding_agent",
 }
 
+# Registry of copyable trust policies
+TRUST = {
+    "open": "open.md",
+    "careful": "careful.md",
+    "strict": "strict.md",
+}
+
 
 def handle_copy(
     names: List[str],
@@ -82,11 +89,14 @@ def handle_copy(
     import connectonion.useful_plugins as plugins_module
     import connectonion.tui as tui_module
     import connectonion.useful_prompts as prompts_module
+    import connectonion
 
     useful_tools_dir = Path(tools_module.__file__).parent
     useful_plugins_dir = Path(plugins_module.__file__).parent
     tui_dir = Path(tui_module.__file__).parent
     useful_prompts_dir = Path(prompts_module.__file__).parent
+    # Trust policies are in the main package's prompts/trust/ directory
+    trust_dir = Path(connectonion.__file__).parent.parent / "prompts" / "trust"
 
     current_dir = Path.cwd()
 
@@ -123,6 +133,13 @@ def handle_copy(
             dest_dir = Path(path) if path else current_dir / "prompts"
             copy_directory(source, dest_dir, force)
 
+        # Check if it's a trust policy (support both "careful" and "trust/careful")
+        elif name_lower in TRUST or (name_lower.startswith("trust/") and name_lower[6:] in TRUST):
+            policy_name = name_lower[6:] if name_lower.startswith("trust/") else name_lower
+            source = trust_dir / TRUST[policy_name]
+            dest_dir = Path(path) if path else current_dir / "prompts" / "trust"
+            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")
@@ -180,9 +197,13 @@ def show_available_items():
     for name, dir_name in sorted(PROMPTS.items()):
         table.add_row(name, "prompt", f"{dir_name}/")
 
+    for name, file in sorted(TRUST.items()):
+        table.add_row(f"trust/{name}", "trust", file)
+
     for name, file in sorted(TUI.items()):
         table.add_row(name, "tui", file)
 
     console.print(table)
     console.print("\n[dim]Usage: co copy <name> [--path ./custom/][/dim]")
     console.print("[dim]Prompts are copied as directories to ./prompts/<name>/[/dim]")
+    console.print("[dim]Trust policies are copied to ./prompts/trust/<name>.md[/dim]")

connectonion-0.6.5/connectonion/cli/commands/trust_commands.py

@@ -0,0 +1,152 @@
+"""
+CLI commands for managing trust lists (contacts, whitelist, blocklist, admins).
+
+Addresses are shown in full (not truncated) so users can easily copy them
+for use in other commands or configuration files.
+
+Usage:
+    co trust list                    # List all trust lists
+    co trust level <address>         # Check trust level of address
+    co trust add <address>           # Add to contacts (default)
+    co trust add <address> -w        # Add to whitelist
+    co trust remove <address>        # Remove from all lists
+    co trust block <address>         # Block an address
+    co trust unblock <address>       # Unblock an address
+    co trust admin add <address>     # Add admin (super admin only)
+    co trust admin remove <address>  # Remove admin (super admin only)
+"""
+
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+
+from ...network.trust.tools import (
+    CO_DIR,
+    get_level,
+    promote_to_contact,
+    promote_to_whitelist,
+    demote_to_stranger,
+    block,
+    unblock,
+    add_admin,
+    remove_admin,
+    load_admins,
+    get_self_address,
+)
+
+console = Console()
+
+
+def _read_list(list_name: str) -> list[str]:
+    """Read entries from a list file."""
+    list_path = CO_DIR / f"{list_name}.txt"
+    if not list_path.exists():
+        return []
+    content = list_path.read_text(encoding='utf-8')
+    return [line.strip() for line in content.splitlines()
+            if line.strip() and not line.startswith('#')]
+
+
+def handle_trust_list():
+    """List all trust lists."""
+    contacts = _read_list("contacts")
+    whitelist = _read_list("whitelist")
+    blocklist = _read_list("blocklist")
+    admins = load_admins()
+    self_addr = get_self_address()
+
+    console.print()
+
+    # Admins
+    console.print("[bold]Admins[/bold]")
+    if admins:
+        for addr in admins:
+            label = " [dim](self)[/dim]" if addr == self_addr else ""
+            console.print(f"  {addr}{label}")
+    else:
+        console.print("  [dim]No admins configured[/dim]")
+    console.print()
+
+    # Whitelist
+    console.print("[bold]Whitelist[/bold] [dim](full trust)[/dim]")
+    if whitelist:
+        for addr in whitelist:
+            console.print(f"  {addr}")
+    else:
+        console.print("  [dim]Empty[/dim]")
+    console.print()
+
+    # Contacts
+    console.print("[bold]Contacts[/bold] [dim](verified via invite/payment)[/dim]")
+    if contacts:
+        for addr in contacts:
+            console.print(f"  {addr}")
+    else:
+        console.print("  [dim]Empty[/dim]")
+    console.print()
+
+    # Blocklist
+    console.print("[bold]Blocklist[/bold] [dim](denied access)[/dim]")
+    if blocklist:
+        for addr in blocklist:
+            console.print(f"  [red]{addr}[/red]")
+    else:
+        console.print("  [dim]Empty[/dim]")
+    console.print()
+
+    console.print(f"[dim]Lists stored in: {CO_DIR}[/dim]")
+
+
+def handle_trust_level(address: str):
+    """Check trust level of an address."""
+    level = get_level(address)
+
+    level_colors = {
+        "stranger": "dim",
+        "contact": "cyan",
+        "whitelist": "green",
+        "blocked": "red",
+    }
+    color = level_colors.get(level, "white")
+
+    console.print(f"\n{address}: [{color}]{level}[/{color}]\n")
+
+
+def handle_trust_add(address: str, whitelist: bool = False):
+    """Add address to contacts or whitelist."""
+    if whitelist:
+        result = promote_to_whitelist(address)
+        console.print(f"\n[green]✓[/green] {result}\n")
+    else:
+        result = promote_to_contact(address)
+        console.print(f"\n[green]✓[/green] {result}\n")
+
+
+def handle_trust_remove(address: str):
+    """Remove address from all lists (demote to stranger)."""
+    result = demote_to_stranger(address)
+    console.print(f"\n[yellow]✓[/yellow] {result}\n")
+
+
+def handle_trust_block(address: str, reason: str = ""):
+    """Block an address."""
+    result = block(address, reason)
+    console.print(f"\n[red]✓[/red] {result}\n")
+
+
+def handle_trust_unblock(address: str):
+    """Unblock an address."""
+    result = unblock(address)
+    console.print(f"\n[green]✓[/green] {result}\n")
+
+
+def handle_admin_add(address: str):
+    """Add an admin."""
+    result = add_admin(address)
+    console.print(f"\n[green]✓[/green] {result}\n")
+
+
+def handle_admin_remove(address: str):
+    """Remove an admin."""
+    result = remove_admin(address)
+    console.print(f"\n[yellow]✓[/yellow] {result}\n")

{connectonion-0.6.4 → connectonion-0.6.5}/connectonion/cli/main.py

@@ -56,6 +56,7 @@ def _show_help():
     console.print("  [green]init[/green]              Initialize in current directory")
     console.print("  [green]copy[/green]   <name>     Copy tool/plugin source to project")
     console.print("  [green]eval[/green]              Run evals and show status")
+    console.print("  [green]trust[/green]             Manage trust lists")
     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")
@@ -174,6 +175,87 @@ def eval(
     handle_eval(name=name, agent_file=agent)
 
 
+# Trust command group
+trust_app = typer.Typer(help="Manage trust lists (contacts, whitelist, blocklist, admins)")
+app.add_typer(trust_app, name="trust")
+
+
+@trust_app.callback(invoke_without_command=True)
+def trust_callback(ctx: typer.Context):
+    """Trust list management."""
+    if ctx.invoked_subcommand is None:
+        # Default to list
+        from .commands.trust_commands import handle_trust_list
+        handle_trust_list()
+
+
+@trust_app.command("list")
+def trust_list():
+    """List all trust lists."""
+    from .commands.trust_commands import handle_trust_list
+    handle_trust_list()
+
+
+@trust_app.command("level")
+def trust_level(address: str = typer.Argument(..., help="Address to check")):
+    """Check trust level of an address."""
+    from .commands.trust_commands import handle_trust_level
+    handle_trust_level(address)
+
+
+@trust_app.command("add")
+def trust_add(
+    address: str = typer.Argument(..., help="Address to add"),
+    whitelist: bool = typer.Option(False, "-w", "--whitelist", help="Add to whitelist instead of contacts"),
+):
+    """Add address to contacts (default) or whitelist."""
+    from .commands.trust_commands import handle_trust_add
+    handle_trust_add(address, whitelist)
+
+
+@trust_app.command("remove")
+def trust_remove(address: str = typer.Argument(..., help="Address to remove")):
+    """Remove address from all lists (demote to stranger)."""
+    from .commands.trust_commands import handle_trust_remove
+    handle_trust_remove(address)
+
+
+@trust_app.command("block")
+def trust_block(
+    address: str = typer.Argument(..., help="Address to block"),
+    reason: str = typer.Option("", "-r", "--reason", help="Reason for blocking"),
+):
+    """Block an address."""
+    from .commands.trust_commands import handle_trust_block
+    handle_trust_block(address, reason)
+
+
+@trust_app.command("unblock")
+def trust_unblock(address: str = typer.Argument(..., help="Address to unblock")):
+    """Unblock an address."""
+    from .commands.trust_commands import handle_trust_unblock
+    handle_trust_unblock(address)
+
+
+# Admin subcommand group
+admin_app = typer.Typer(help="Manage admins (super admin only)")
+trust_app.add_typer(admin_app, name="admin")
+
+
+@admin_app.command("add")
+def admin_add(address: str = typer.Argument(..., help="Address to add as admin")):
+    """Add an admin."""
+    from .commands.trust_commands import handle_admin_add
+    handle_admin_add(address)
+
+
+@admin_app.command("remove")
+def admin_remove(address: str = typer.Argument(..., help="Address to remove from admins")):
+    """Remove an admin."""
+    from .commands.trust_commands import handle_admin_remove
+    handle_admin_remove(address)
+
+
 def cli():
     """Entry point."""
     app()

{connectonion-0.6.4 → connectonion-0.6.5}/connectonion/core/llm.py

@@ -3,7 +3,7 @@ Purpose: Unified LLM provider abstraction with factory pattern for OpenAI, Anthr
 LLM-Note:
   Dependencies: imports from [abc, typing, dataclasses, json, os, base64, openai, anthropic, requests, pathlib, toml, pydantic, .usage, .exceptions] | imported by [agent.py, llm_do.py, conftest.py] | tested by [tests/test_llm.py, tests/test_llm_do.py, tests/test_real_*.py, tests/test_billing_error_agent.py]
   Data flow: Agent/llm_do calls create_llm(model, api_key) → factory routes to provider class → Provider.__init__() validates API key → Agent calls complete(messages, tools) OR structured_complete(messages, output_schema) → provider converts to native format → calls API → parses response → returns LLMResponse(content, tool_calls, raw_response) OR Pydantic model instance
-  State/Effects: reads environment variables (OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, OPENONION_API_KEY) | reads ~/.connectonion/.co/config.toml for OpenOnion auth | makes HTTP requests to LLM APIs | no caching or persistence
+  State/Effects: reads environment variables (OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, OPENONION_API_KEY) | reads ~/.co/config.toml for OpenOnion auth | makes HTTP requests to LLM APIs | no caching or persistence
   Integration: exposes create_llm(model, api_key), LLM abstract base class, OpenAILLM, AnthropicLLM, GeminiLLM, OpenOnionLLM, LLMResponse, ToolCall dataclasses | providers implement complete() and structured_complete() | OpenAI message format is lingua franca | tool calling uses OpenAI schema converted per-provider
   Performance: stateless (no caching) | synchronous (no streaming) | default max_tokens=8192 for Anthropic (required) | each call hits API
   Errors: raises ValueError for missing API keys, unknown models, invalid parameters | provider-specific errors bubble up (openai.APIError, anthropic.APIError, etc.) | OpenOnionLLM transforms 402 errors to InsufficientCreditsError with formatted message and typed attributes | Pydantic ValidationError for invalid structured output
@@ -97,7 +97,7 @@ Required (pick one):
   - OPENAI_API_KEY: For OpenAI models
   - ANTHROPIC_API_KEY: For Claude models
   - GEMINI_API_KEY or GOOGLE_API_KEY: For Gemini models
-  - OPENONION_API_KEY: For co/ managed keys (or from ~/.connectonion/.co/config.toml)
+  - OPENONION_API_KEY: For co/ managed keys (or from ~/.co/config.toml)
 
 Optional:
   - OPENONION_DEV: Use localhost:8000 for OpenOnion (development)