connectonion 0.6.3__tar.gz → 0.6.5__tar.gz

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

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

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

{connectonion-0.6.3 → connectonion-0.6.5}/connectonion/cli/co_ai/agent.py

@@ -12,9 +12,9 @@ from .tools import (
     load_guide,
 )
 from .skills import skill
-from .plugins import reminder_plugin
+from .plugins import system_reminder
 from connectonion import Agent, bash, after_user_input, FileWriter, MODE_AUTO, MODE_NORMAL, TodoList
-from connectonion.useful_plugins import re_act, eval
+from connectonion.useful_plugins import eval, tool_approval
 
 
 PROMPTS_DIR = Path(__file__).parent / "prompts"
@@ -71,7 +71,7 @@ def create_coding_agent(
     if project_context:
         system_prompt += f"\n\n---\n\n{project_context}"
 
-    plugins = [re_act, eval, reminder_plugin]
+    plugins = [eval, system_reminder, tool_approval]
 
     agent = Agent(
         name="oo",

{connectonion-0.6.3 → 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/plugins/__init__.py

@@ -0,0 +1,5 @@
+"""OO Agent plugins."""
+
+from .system_reminder import system_reminder
+
+__all__ = ['system_reminder']

connectonion-0.6.5/connectonion/cli/co_ai/plugins/system_reminder.py

@@ -0,0 +1,154 @@
+"""
+System Reminder Plugin - Injects contextual guidance based on intent and tool usage.
+
+Two triggers:
+1. after_user_input: Detect intent (coding, agent creation) and inject relevant reminder
+2. after_each_tool: Inject reminder based on tool usage
+
+Usage:
+    from connectonion.cli.co_ai.plugins.system_reminder import system_reminder
+
+    agent = Agent("coder", plugins=[system_reminder])
+"""
+
+from pathlib import Path
+import fnmatch
+from typing import TYPE_CHECKING
+
+from connectonion.core.events import after_each_tool, after_user_input
+from connectonion.llm_do import llm_do
+
+if TYPE_CHECKING:
+    from connectonion.core.agent import Agent
+
+# Default reminders directory
+REMINDERS_DIR = Path(__file__).parent.parent / "prompts" / "system-reminders"
+
+# Intent detection prompt
+INTENT_PROMPT = """Analyze the user's request.
+
+User request: {user_prompt}
+
+Is this about building software, creating agents, writing code, or automation?
+Respond with ONE word only: "build" or "other"
+
+One word only:"""
+
+
+def _parse_frontmatter(text):
+    """Parse YAML frontmatter from markdown."""
+    if not text.startswith('---'):
+        return {}, text
+    parts = text.split('---', 2)
+    if len(parts) < 3:
+        return {}, text
+    import yaml
+    return yaml.safe_load(parts[1]) or {}, parts[2].strip()
+
+
+def _load_reminders(reminders_dir):
+    """Load all .md reminder files from directory."""
+    reminders_dir = Path(reminders_dir)
+    if not reminders_dir.exists():
+        return {}
+    reminders = {}
+    for f in reminders_dir.glob("*.md"):
+        meta, body = _parse_frontmatter(f.read_text())
+        if meta.get('name'):
+            reminders[meta['name']] = {
+                'content': body,
+                'triggers': meta.get('triggers', []),
+                'intent': meta.get('intent'),  # New: intent-based trigger
+            }
+    return reminders
+
+
+def _matches_pattern(pattern, value):
+    """Check if value matches glob pattern(s)."""
+    if not pattern or not value:
+        return False
+    patterns = [pattern] if isinstance(pattern, str) else pattern
+    return any(fnmatch.fnmatch(value, p) for p in patterns)
+
+
+def _find_tool_reminder(reminders, tool_name, args):
+    """Find matching reminder for tool usage."""
+    for reminder in reminders.values():
+        for trigger in reminder['triggers']:
+            if trigger.get('tool') and trigger['tool'] != tool_name:
+                continue
+            if trigger.get('path_pattern'):
+                path = args.get('path') or args.get('file_path', '')
+                if not _matches_pattern(trigger['path_pattern'], path):
+                    continue
+            if trigger.get('command_pattern'):
+                cmd = args.get('command') or args.get('cmd', '')
+                if not _matches_pattern(trigger['command_pattern'], cmd):
+                    continue
+            # All conditions matched
+            content = reminder['content']
+            path = args.get('path') or args.get('file_path', '')
+            return content.replace('${file_path}', path).replace('${tool_name}', tool_name)
+    return None
+
+
+def _find_intent_reminder(reminders, intent):
+    """Find matching reminder for detected intent."""
+    for reminder in reminders.values():
+        if reminder.get('intent') == intent:
+            return reminder['content']
+    return None
+
+
+# Load reminders once at import
+_REMINDERS = _load_reminders(REMINDERS_DIR)
+
+
+@after_user_input
+def detect_intent(agent: 'Agent') -> None:
+    """Detect user intent and inject relevant system reminder."""
+    user_prompt = agent.current_session.get('user_prompt', '')
+    if not user_prompt:
+        return
+
+    # Use llm_do to detect intent
+    intent = llm_do(
+        INTENT_PROMPT.format(user_prompt=user_prompt),
+        model="co/gemini-2.5-flash",
+        temperature=0,
+    ).strip().lower()
+
+    # Store intent in session
+    agent.current_session['intent'] = intent
+
+    # Find and inject intent-based reminder
+    content = _find_intent_reminder(_REMINDERS, intent)
+    if content:
+        agent.current_session['messages'].append({
+            'role': 'user',
+            'content': f"\n\n{content}"
+        })
+
+
+@after_each_tool
+def inject_tool_reminder(agent: 'Agent') -> None:
+    """Inject matching system reminder into tool result."""
+    trace = agent.current_session.get('trace', [])
+    messages = agent.current_session.get('messages', [])
+    if not trace or not messages:
+        return
+
+    last = trace[-1]
+    if last.get('type') != 'tool_result':
+        return
+
+    content = _find_tool_reminder(_REMINDERS, last.get('name', ''), last.get('args', {}))
+    if content:
+        for msg in reversed(messages):
+            if msg.get('role') == 'tool':
+                msg['content'] = msg.get('content', '') + '\n\n' + content
+                break
+
+
+# Export plugin
+system_reminder = [detect_intent, inject_tool_reminder]

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.5/connectonion/cli/co_ai/prompts/system-reminders/agent.md

@@ -0,0 +1,23 @@
+---
+name: build
+intent: build
+---
+
+<system-reminder>
+Agent creation detected. Use ConnectOnion framework:
+
+**ConnectOnion agents are Python files (.py), NOT markdown files.**
+
+```python
+from connectonion import Agent
+
+def list_files(dir: str) -> list[str]: ...
+def get_hash(path: str) -> str: ...
+def delete(path: str) -> str: ...
+
+agent = Agent("cleaner", tools=[list_files, get_hash, delete])
+agent.input("Remove duplicate files")
+```
+
+**Give tools, not logic. Let the agent decide strategy. NEVER create standalone scripts with hardcoded logic.**
+</system-reminder>

connectonion-0.6.5/connectonion/cli/co_ai/prompts/system-reminders/plan_mode.md

@@ -0,0 +1,13 @@
+---
+name: plan-mode
+triggers:
+  - tool: enter_plan_mode
+---
+
+<system-reminder>
+Plan mode is active. You MUST NOT make any edits or run non-readonly tools.
+
+Only allowed: glob, grep, read_file, write_plan, exit_plan_mode
+
+Write your plan to the plan file, then call exit_plan_mode when done.
+</system-reminder>

connectonion-0.6.5/connectonion/cli/co_ai/prompts/system-reminders/security.md

@@ -0,0 +1,14 @@
+---
+name: security
+triggers:
+  - tool: read_file
+    path_pattern: ["*.env*", "*credentials*", "*secrets*", "*password*", "*token*", "*.pem", "*.key"]
+  - tool: read
+    path_pattern: ["*.env*", "*credentials*", "*secrets*", "*password*", "*token*", "*.pem", "*.key"]
+---
+
+<system-reminder>
+This file may contain sensitive information.
+- Never expose secrets in output
+- Never commit real credentials
+</system-reminder>

connectonion-0.6.5/connectonion/cli/co_ai/prompts/system-reminders/simplicity.md

@@ -0,0 +1,14 @@
+---
+name: simplicity
+triggers:
+  - tool: edit
+  - tool: multi_edit
+  - tool: write
+---
+
+<system-reminder>
+Keep it simple:
+- Only change what's directly needed
+- Don't add error handling for scenarios that can't happen
+- Three similar lines > premature abstraction
+</system-reminder>

{connectonion-0.6.3 → connectonion-0.6.5}/connectonion/cli/co_ai/tools/plan_mode.py

@@ -6,8 +6,6 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.markdown import Markdown
 
-from connectonion.cli.co_ai.reminders import REMINDERS
-
 console = Console()
 
 # Plan mode state (module-level for simplicity)
@@ -101,8 +99,7 @@ def enter_plan_mode() -> str:
         border_style="green"
     ))
 
-    plan_mode_reminder = REMINDERS.get("plan_mode_active", "")
-    return f"Entered plan mode. Write your plan to {_plan_file_path}, then call exit_plan_mode() when ready for user approval.\n\n{plan_mode_reminder}"
+    return f"Entered plan mode. Write your plan to {_plan_file_path}, then call exit_plan_mode() when ready for user approval."
 
 
 def exit_plan_mode() -> str:

{connectonion-0.6.3 → connectonion-0.6.5}/connectonion/cli/co_ai/tools/read.py

@@ -3,8 +3,6 @@
 from pathlib import Path
 from typing import Optional
 
-from connectonion.cli.co_ai.reminders import inject_reminder, should_show_security_reminder
-
 
 def read_file(
     path: str,
@@ -60,8 +58,4 @@ def read_file(
     if end < total_lines:
         result += f"\n\n... ({total_lines - end} more lines)"
 
-    # Inject security reminder for sensitive files
-    if should_show_security_reminder(path):
-        result = inject_reminder(result, "security")
-
     return result

{connectonion-0.6.3 → 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]")