connectonion 0.4.11__py3-none-any.whl → 0.5.0__py3-none-any.whl

tests/conftest.py

@@ -1,283 +0,0 @@
-"""Pytest configuration and shared fixtures for ConnectOnion tests."""
-
-import pytest
-import tempfile
-import shutil
-import json
-from pathlib import Path
-from unittest.mock import Mock, MagicMock
-from connectonion import Agent
-# No need to import tools - they're just functions
-from connectonion.llm import LLMResponse, ToolCall, OpenAILLM
-from connectonion.usage import TokenUsage
-import os
-from dotenv import load_dotenv
-
-# Load .env file for API keys
-load_dotenv()
-
-
-@pytest.fixture
-def temp_dir():
-    """Create a temporary directory for tests."""
-    temp_dir = tempfile.mkdtemp()
-    yield temp_dir
-    shutil.rmtree(temp_dir)
-
-
-@pytest.fixture
-def mock_openai_client():
-    """Create a mock OpenAI client for testing."""
-    mock_client = MagicMock()
-    
-    # Default successful response
-    mock_response = MagicMock()
-    mock_response.choices = [MagicMock()]
-    mock_response.choices[0].message.content = "Test response"
-    mock_response.choices[0].message.tool_calls = None
-    
-    mock_client.chat.completions.create.return_value = mock_response
-    return mock_client
-
-
-@pytest.fixture
-def mock_llm():
-    """Create a mock LLM instance."""
-    mock = Mock(spec=OpenAILLM)
-    mock.complete.return_value = LLMResponse(
-        content="Mock response",
-        tool_calls=[],
-        raw_response=None,
-        usage=TokenUsage(),
-    )
-    return mock
-
-
-# Tool functions for testing
-def calculator(expression: str) -> str:
-    """Perform mathematical calculations."""
-    try:
-        result = eval(expression)
-        return f"Result: {result}"
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-def current_time() -> str:
-    """Get the current time."""
-    from datetime import datetime
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-def read_file(file_path: str) -> str:
-    """Read content from a file."""
-    try:
-        with open(file_path, 'r') as f:
-            return f.read()
-    except FileNotFoundError:
-        return f"Error: File not found: {file_path}"
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-@pytest.fixture
-def sample_tools():
-    """Standard set of test tools."""
-    return [calculator, current_time, read_file]
-
-
-@pytest.fixture
-def test_agent(temp_dir, mock_llm, sample_tools):
-    """Create a test agent with logging to temp directory."""
-    # Use temp directory for logging instead of default .co/logs/
-    log_file = Path(temp_dir) / "test_agent.log"
-    agent = Agent(name="test_agent", llm=mock_llm, tools=sample_tools, log=log_file)
-    return agent
-
-
-@pytest.fixture
-def sample_behavior_records():
-    """Sample behavior records for testing."""
-    return [
-        {
-            "timestamp": "2025-07-28T10:00:00.000000",
-            "task": "Calculate 2 + 2",
-            "tool_calls": [
-                {
-                    "name": "calculator",
-                    "arguments": {"expression": "2 + 2"},
-                    "call_id": "call_123",
-                    "result": "Result: 4",
-                    "status": "success"
-                }
-            ],
-            "result": "The answer is 4",
-            "duration_seconds": 1.5
-        },
-        {
-            "timestamp": "2025-07-28T10:01:00.000000",
-            "task": "What time is it?",
-            "tool_calls": [
-                {
-                    "name": "current_time",
-                    "arguments": {},
-                    "call_id": "call_456",
-                    "result": "2025-07-28 10:01:00",
-                    "status": "success"
-                }
-            ],
-            "result": "Current time is 10:01 AM",
-            "duration_seconds": 0.8
-        }
-    ]
-
-
-@pytest.fixture
-def sample_openai_responses():
-    """Sample OpenAI API responses for testing."""
-    return {
-        "simple_text": {
-            "id": "chatcmpl-123",
-            "object": "chat.completion",
-            "choices": [{
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": "Hello! I'm a helpful assistant."
-                },
-                "finish_reason": "stop"
-            }]
-        },
-        "tool_calling": {
-            "id": "chatcmpl-456", 
-            "object": "chat.completion",
-            "choices": [{
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": None,
-                    "tool_calls": [{
-                        "id": "call_abc123",
-                        "type": "function",
-                        "function": {
-                            "name": "calculator",
-                            "arguments": '{"expression": "2 + 2"}'
-                        }
-                    }]
-                },
-                "finish_reason": "tool_calls"
-            }]
-        }
-    }
-
-
-@pytest.fixture
-def test_files(temp_dir):
-    """Create test files for ReadFile tool testing."""
-    files = {}
-    
-    # Normal text file
-    normal_file = Path(temp_dir) / "normal.txt"
-    normal_file.write_text("Hello, ConnectOnion!")
-    files["normal"] = str(normal_file)
-    
-    # Empty file
-    empty_file = Path(temp_dir) / "empty.txt"
-    empty_file.write_text("")
-    files["empty"] = str(empty_file)
-    
-    # Large file
-    large_file = Path(temp_dir) / "large.txt"
-    large_content = "Line {}\n" * 10000
-    large_file.write_text(large_content.format(*range(10000)))
-    files["large"] = str(large_file)
-    
-    # Unicode file
-    unicode_file = Path(temp_dir) / "unicode.txt"
-    unicode_file.write_text("Hello 🌍 世界 🚀", encoding="utf-8")
-    files["unicode"] = str(unicode_file)
-    
-    return files
-
-
-@pytest.fixture
-def openai_api_key():
-    """Provide test API key."""
-    return "sk-test-key-for-testing-only"
-
-
-# Load environment variables from tests/.env
-env_file = Path(__file__).parent / ".env"
-if env_file.exists():
-    load_dotenv(env_file)
-else:
-    print("\n⚠️  Warning: tests/.env not found!")
-    print("   Some tests may fail without API keys.")
-    print("   Copy tests/.env.example to tests/.env and add your API keys.\n")
-
-
-# Network test fixtures
-@pytest.fixture
-def relay_url():
-    """
-    Default relay URL for network tests.
-
-    Uses production relay server by default.
-    Override with --relay-url flag or RELAY_URL env var.
-    """
-    return os.getenv("RELAY_URL", "wss://oo.openonion.ai/ws/announce")
-
-
-@pytest.fixture
-def local_relay_url():
-    """Local relay URL for development/testing."""
-    return "ws://localhost:8000/ws/announce"
-
-
-@pytest.fixture
-def relay_url_from_cli(request):
-    """Get relay URL from command line or use default."""
-    if request.config.getoption("--use-local-relay"):
-        return "ws://localhost:8000/ws/announce"
-    return request.config.getoption("--relay-url")
-
-
-# Test markers and CLI options
-def pytest_configure(config):
-    """Configure custom pytest markers."""
-    config.addinivalue_line("markers", "slow: marks tests as slow (deselect with '-m \"not slow\"')")
-    config.addinivalue_line("markers", "integration: marks tests as integration tests")
-    config.addinivalue_line("markers", "unit: marks tests as unit tests")
-    config.addinivalue_line("markers", "benchmark: marks tests as performance benchmarks")
-
-
-def pytest_addoption(parser):
-    """Add custom command line options."""
-    parser.addoption(
-        "--relay-url",
-        action="store",
-        default="wss://oo.openonion.ai/ws/announce",
-        help="Relay server URL for network tests"
-    )
-    parser.addoption(
-        "--use-local-relay",
-        action="store_true",
-        help="Use local relay server (ws://localhost:8000/ws/announce)"
-    )
-
-
-def pytest_collection_modifyitems(config, items):
-    """Auto-skip tests that need API keys if keys are missing."""
-
-    # Check for API keys
-    has_openai = bool(os.getenv("OPENAI_API_KEY"))
-    has_anthropic = bool(os.getenv("ANTHROPIC_API_KEY"))
-    has_google = bool(os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY"))
-    has_openonion = bool(os.getenv("OPENONION_API_KEY"))
-
-    has_any_key = has_openai or has_anthropic or has_google or has_openonion
-
-    if not has_any_key:
-        skip_marker = pytest.mark.skip(
-            reason="API keys not found. Copy tests/.env.example to tests/.env and add your keys."
-        )
-        for item in items:
-            if "real_api" in item.keywords:
-                item.add_marker(skip_marker)

tests/debug_gemini_models.py

@@ -1,23 +0,0 @@
-"""
-Debug script to list available Gemini models and their supported methods.
-"""
-import os
-import google.generativeai as genai
-from dotenv import load_dotenv
-from pathlib import Path
-
-# Load environment variables from tests/.env
-env_path = Path(__file__).parent / ".env"
-if env_path.exists():
-    load_dotenv(env_path)
-
-api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
-if not api_key:
-    print("Error: GEMINI_API_KEY or GOOGLE_API_KEY not found in environment.")
-else:
-    genai.configure(api_key=api_key)
-    print("--- Available Gemini Models ---")
-    for m in genai.list_models():
-        print(f"- Model: {m.name}")
-        print(f"  Supported Methods: {m.supported_generation_methods}")
-        print("-" * 10)

tests/fixtures/__init__.py

@@ -1 +0,0 @@
-"""Test fixtures for ConnectOnion tests."""

tests/fixtures/test_tools.py

@@ -1,112 +0,0 @@
-"""Test tool fixtures for ConnectOnion tests.
-
-This module provides both function-based and class-based tools for testing.
-The agent supports both patterns:
-- Functions: tools=[calculator, current_time]
-- Class instances: tools=[CalculatorTool(), TimeTool()]
-"""
-import os
-from datetime import datetime
-from typing import Optional
-
-
-# ============================================================================
-# FUNCTION-BASED TOOLS (snake_case naming)
-# ============================================================================
-
-def calculator(expression: str) -> str:
-    """Calculate mathematical expressions."""
-    try:
-        result = eval(expression)
-        return str(result)
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-
-def current_time() -> str:
-    """Get the current time."""
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-
-def read_file(filepath: str) -> str:
-    """Read contents of a file."""
-    try:
-        if not os.path.exists(filepath):
-            return f"Error: File not found: {filepath}"
-        with open(filepath, 'r') as f:
-            return f.read()
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-
-def write_file(filepath: str, content: str) -> str:
-    """Write content to a file."""
-    try:
-        with open(filepath, 'w') as f:
-            f.write(content)
-        return f"Successfully wrote to {filepath}"
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-
-def search_web(query: str, limit: Optional[int] = 5) -> str:
-    """Mock web search tool."""
-    return f"Search results for '{query}': [Result 1, Result 2, Result 3]"
-
-
-# ============================================================================
-# CLASS-BASED TOOLS (PascalCase naming)
-# ============================================================================
-
-class CalculatorTool:
-    """Calculator tool as a class (methods become individual tools)."""
-
-    def calculate(self, expression: str) -> str:
-        """Calculate mathematical expressions."""
-        try:
-            result = eval(expression)
-            return str(result)
-        except Exception as e:
-            return f"Error: {str(e)}"
-
-
-class TimeTool:
-    """Time tool as a class."""
-
-    def get_current_time(self) -> str:
-        """Get the current time."""
-        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-
-class FileReaderTool:
-    """File operations tool as a class."""
-
-    def read_file(self, filepath: str) -> str:
-        """Read contents of a file."""
-        try:
-            if not os.path.exists(filepath):
-                return f"Error: File not found: {filepath}"
-            with open(filepath, 'r') as f:
-                return f.read()
-        except Exception as e:
-            return f"Error: {str(e)}"
-
-    def write_file(self, filepath: str, content: str) -> str:
-        """Write content to a file."""
-        try:
-            with open(filepath, 'w') as f:
-                f.write(content)
-            return f"Successfully wrote to {filepath}"
-        except Exception as e:
-            return f"Error: {str(e)}"
-
-
-# ============================================================================
-# LEGACY ALIASES (for backward compatibility)
-# ============================================================================
-
-Calculator = calculator  # Function alias
-CurrentTime = current_time
-ReadFile = read_file
-WriteFile = write_file
-SearchWeb = search_web

tests/fixtures/trust_fixtures.py

@@ -1,257 +0,0 @@
-"""Fixtures for trust-related tests."""
-
-import pytest
-import tempfile
-from pathlib import Path
-from connectonion import Agent
-
-
-@pytest.fixture
-def trust_policy_file(tmp_path):
-    """Create a temporary trust policy file."""
-    policy_file = tmp_path / "trust_policy.md"
-    policy_file.write_text("""# Trust Policy
-
-I trust agents that:
-- Pass my verification tests
-- Respond within 500ms
-- Are from trusted domains
-
-I do not trust agents that:
-- Fail capability tests
-- Take longer than 5 seconds
-- Are on my blacklist
-""")
-    return str(policy_file)
-
-
-@pytest.fixture
-def trust_policy_files(tmp_path):
-    """Create multiple trust policy files for different scenarios."""
-    policies = {}
-    
-    # Open policy
-    open_policy = tmp_path / "open_policy.md"
-    open_policy.write_text("""# Open Trust Policy
-I trust all agents without verification.
-This is suitable for development environments.""")
-    policies['open'] = str(open_policy)
-    
-    # Careful policy
-    careful_policy = tmp_path / "careful_policy.md"
-    careful_policy.write_text("""# Careful Trust Policy
-I trust agents that:
-- Pass basic capability tests
-- Demonstrate consistent behavior
-- Respond in reasonable time
-
-I verify each agent before first use.""")
-    policies['careful'] = str(careful_policy)
-    
-    # Strict policy
-    strict_policy = tmp_path / "strict_policy.md"
-    strict_policy.write_text("""# Strict Trust Policy
-I only trust agents that:
-- Are explicitly whitelisted
-- Pass comprehensive security checks
-- Have valid credentials
-- Come from approved domains
-
-All others are rejected.""")
-    policies['strict'] = str(strict_policy)
-    
-    return policies
-
-
-@pytest.fixture
-def mock_trust_agent():
-    """Create a mock trust agent for testing."""
-    def verify_agent(agent_id: str) -> bool:
-        """Verify if an agent can be trusted."""
-        # Mock verification - trusts specific test agents
-        return agent_id in ["trusted_one", "trusted_two", "test_agent"]
-    
-    def check_capability(agent_id: str, test: str, expected: str) -> bool:
-        """Check agent capability with a test."""
-        # Mock capability check
-        return True
-    
-    return Agent(
-        name="mock_guardian",
-        tools=[verify_agent, check_capability],
-        system_prompt="I am a mock trust guardian for testing"
-    )
-
-
-@pytest.fixture
-def strict_trust_agent():
-    """Create a strict trust agent that only trusts whitelisted agents."""
-    def check_whitelist(agent_id: str) -> bool:
-        """Check if agent is on the whitelist."""
-        whitelist = ["production_service", "verified_api", "trusted_partner"]
-        return agent_id in whitelist
-    
-    def verify_credentials(agent_id: str, credentials: dict) -> bool:
-        """Verify agent credentials."""
-        # Mock credential verification
-        return credentials.get("api_key", "").startswith("valid_")
-    
-    def check_domain(agent_id: str, domain: str) -> bool:
-        """Check if agent is from approved domain."""
-        approved_domains = ["*.trusted.com", "*.company.internal", "localhost"]
-        # Simplified domain check for testing
-        return any(domain.endswith(d.replace("*.", "")) for d in approved_domains)
-    
-    return Agent(
-        name="strict_guardian",
-        tools=[check_whitelist, verify_credentials, check_domain],
-        system_prompt="I am a strict trust guardian. I only trust pre-approved agents.",
-        trust="open"  # The guardian itself is open (doesn't need trust to operate)
-    )
-
-
-@pytest.fixture
-def sample_trust_policies():
-    """Sample trust policies for testing."""
-    return {
-        "simple_open": "I trust everyone",
-        "simple_careful": "I verify agents before trusting them",
-        "simple_strict": "I only trust whitelisted agents",
-        "detailed_careful": """# Careful Trust Policy
-I trust agents that:
-- Pass my capability tests
-- Have good reputation scores
-- Respond within acceptable time limits
-
-I test each new agent with:
-- Basic functionality test
-- Response time measurement
-- Error handling verification""",
-        "detailed_strict": """# Strict Security Policy
-Requirements for trust:
-1. Agent must be on pre-approved whitelist
-2. Agent must have valid security credentials
-3. Agent must pass all security audits
-4. Agent must use encrypted communication
-
-Automatic rejection for:
-- Unknown agents
-- Agents with failed tests
-- Agents from untrusted networks""",
-        "payment_processor": """# Payment Processor Trust Policy
-This is a high-security trust policy for payment processing.
-
-I ONLY trust agents that:
-- Are explicitly whitelisted by security team
-- Have PCI compliance certification
-- Use end-to-end encryption
-- Have passed penetration testing
-- Maintain audit logs
-
-I immediately reject:
-- Any agent not on whitelist
-- Agents without proper credentials
-- Agents from public networks
-- Agents with any failed security checks"""
-    }
-
-
-@pytest.fixture
-def sample_verification_tools():
-    """Sample verification tool functions for trust agents."""
-    
-    def check_whitelist(agent_id: str) -> bool:
-        """Check if agent is whitelisted."""
-        # Read from mock whitelist
-        whitelist = ["alice", "bob", "trusted_service"]
-        return agent_id in whitelist
-    
-    def test_capability(agent_id: str, test_input: str, expected_output: str) -> bool:
-        """Test agent capability."""
-        # Mock test - in reality would call the agent
-        return True  # Simplified for testing
-    
-    def measure_response_time(agent_id: str, timeout_ms: int = 1000) -> float:
-        """Measure agent response time."""
-        # Mock measurement
-        import random
-        return random.uniform(100, 900)  # Mock response time in ms
-    
-    def check_local_network(agent_ip: str) -> bool:
-        """Check if agent is on local network."""
-        # Mock check
-        return agent_ip.startswith("192.168.") or agent_ip == "localhost"
-    
-    def verify_credentials(agent_id: str, token: str) -> bool:
-        """Verify agent credentials."""
-        # Mock credential check
-        return token.startswith("valid_token_")
-    
-    return {
-        'check_whitelist': check_whitelist,
-        'test_capability': test_capability,
-        'measure_response_time': measure_response_time,
-        'check_local_network': check_local_network,
-        'verify_credentials': verify_credentials
-    }
-
-
-@pytest.fixture
-def trust_test_agents():
-    """Create test agents with different trust configurations."""
-    
-    def calculator(expression: str) -> str:
-        """Simple calculator tool."""
-        return str(eval(expression))
-    
-    def translator(text: str, to_lang: str = "es") -> str:
-        """Mock translator tool."""
-        translations = {
-            "Hello": {"es": "Hola", "fr": "Bonjour"},
-            "Goodbye": {"es": "Adiós", "fr": "Au revoir"}
-        }
-        return translations.get(text, {}).get(to_lang, f"[{text}]")
-    
-    agents = {}
-    
-    # Open trust agent (development)
-    agents['open'] = Agent(
-        name="dev_agent",
-        tools=[calculator],
-        trust="open",
-        system_prompt="I am a development agent with open trust"
-    )
-    
-    # Careful trust agent (staging)
-    agents['careful'] = Agent(
-        name="staging_agent",
-        tools=[translator],
-        trust="careful",
-        system_prompt="I am a staging agent with careful trust"
-    )
-    
-    # Strict trust agent (production)
-    agents['strict'] = Agent(
-        name="prod_agent",
-        tools=[calculator, translator],
-        trust="strict",
-        system_prompt="I am a production agent with strict trust"
-    )
-    
-    return agents
-
-
-@pytest.fixture
-def whitelist_file(tmp_path):
-    """Create a mock whitelist file."""
-    whitelist = tmp_path / "trusted.txt"
-    whitelist.write_text("""# Trusted agents whitelist
-alice_translator
-bob_calculator
-trusted_api.com
-payment_processor.secure
-*.company.internal
-192.168.1.*
-localhost
-""")
-    return str(whitelist)

tests/real_api/conftest.py

@@ -1,9 +0,0 @@
-import pytest
-
-
-def pytest_collection_modifyitems(items):
-    """Mark all tests in this folder as real API tests."""
-    for item in items:
-        # Check if the test is in the real_api directory
-        if "real_api" in str(item.fspath):
-            item.add_marker(pytest.mark.real_api)