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

tests/real_api/test_production_client.py

@@ -1,94 +0,0 @@
-"""Test connectonion client against production API"""
-import os
-import time
-import requests
-from pydantic import BaseModel
-from nacl.signing import SigningKey
-from nacl.encoding import HexEncoder
-from connectonion import llm_do
-
-
-# Production URL
-PRODUCTION_URL = "http://3.24.102.245"
-
-
-class EmailDraft(BaseModel):
-    """Email draft with subject and body"""
-    subject: str
-    body: str
-
-
-def get_test_token():
-    """Generate test auth token for production backend"""
-    signing_key = SigningKey.generate()
-    public_key = "0x" + signing_key.verify_key.encode(encoder=HexEncoder).decode()
-    timestamp = int(time.time())
-    message = f"ConnectOnion-Auth-{public_key}-{timestamp}"
-    signature = signing_key.sign(message.encode()).signature.hex()
-
-    response = requests.post(
-        f"{PRODUCTION_URL}/api/v1/auth",
-        json={
-            "public_key": public_key,
-            "message": message,
-            "signature": signature
-        }
-    )
-
-    if response.status_code != 200:
-        raise Exception(f"Auth failed: {response.status_code} - {response.text}")
-
-    return response.json()["token"]
-
-
-def test_production_llm_do_structured():
-    """Test llm_do() with structured output against production API"""
-    print("\n" + "=" * 80)
-    print("TESTING CONNECTONION CLIENT AGAINST PRODUCTION")
-    print(f"Target: {PRODUCTION_URL}")
-    print("=" * 80)
-
-    # Point to production instead of localhost
-    os.environ["OPENONION_API_URL"] = PRODUCTION_URL
-
-    # Get auth token from production
-    token = get_test_token()
-    os.environ["OPENONION_API_KEY"] = token
-
-    print("\n✓ Authentication successful")
-    print(f"  Using production API: {PRODUCTION_URL}")
-
-    # Test structured output with co/ model
-    print("\nTesting llm_do() with structured output (EmailDraft)...")
-    draft = llm_do(
-        "Write a friendly hello email to a new colleague",
-        output=EmailDraft,
-        temperature=0.7,
-        model="co/gpt-4o-mini"
-    )
-
-    # Verify we got a valid Pydantic model
-    assert isinstance(draft, EmailDraft)
-    assert isinstance(draft.subject, str)
-    assert isinstance(draft.body, str)
-    assert len(draft.subject) > 0
-    assert len(draft.body) > 0
-
-    print("\n✓ Structured output test PASSED!")
-    print(f"  Subject: {draft.subject}")
-    print(f"  Body preview: {draft.body[:150]}...")
-
-    print("\n" + "=" * 80)
-    print("✅ CONNECTONION CLIENT WORKS WITH PRODUCTION API!")
-    print("   Issue #9 is fully resolved in production")
-    print("=" * 80)
-
-
-if __name__ == "__main__":
-    try:
-        test_production_llm_do_structured()
-    except Exception as e:
-        print(f"\n❌ Production client test failed: {e}")
-        import traceback
-        traceback.print_exc()
-        exit(1)

tests/real_api/test_real_anthropic.py

@@ -1,100 +0,0 @@
-"""
-Real Anthropic API tests.
-
-These tests make actual API calls to Anthropic and cost real money.
-Run with: pytest test_real_anthropic.py -v
-
-Requires: ANTHROPIC_API_KEY environment variable
-"""
-
-import os
-import pytest
-from pathlib import Path
-from dotenv import load_dotenv
-from connectonion import Agent
-from connectonion.llm import AnthropicLLM
-
-# Load environment variables from tests/.env
-env_path = Path(__file__).parent / ".env"
-if env_path.exists():
-    load_dotenv(env_path)
-
-
-def text_processor(text: str) -> str:
-    """Simple text processor for testing."""
-    return f"Processed: {text.upper()}"
-
-
-class TestRealAnthropic:
-    """Test real Anthropic API integration."""
-
-    def test_anthropic_basic_completion(self):
-        """Test basic completion with Anthropic."""
-        llm = AnthropicLLM(model="claude-3-5-haiku-latest")
-        agent = Agent(name="anthropic_test", llm=llm)
-
-        response = agent.input("Say 'Hello from Claude' exactly")
-        assert response is not None
-        assert "Hello from Claude" in response
-
-    def test_anthropic_with_tools(self):
-        """Test Anthropic with tool calling."""
-        agent = Agent(
-            name="anthropic_tools",
-            model="claude-3-5-haiku-latest",
-            tools=[text_processor]
-        )
-
-        response = agent.input("Process the text 'hello world'")
-        assert response is not None
-        assert "HELLO WORLD" in response or "processed" in response.lower()
-
-    def test_anthropic_multi_turn(self):
-        """Test multi-turn conversation with Anthropic."""
-        agent = Agent(
-            name="anthropic_conversation",
-            model="claude-3-5-haiku-latest"
-        )
-
-        # First turn
-        response = agent.input("I'm learning Python. Remember this.")
-        assert response is not None
-
-        # Second turn - should remember context
-        response = agent.input("What programming language am I learning?")
-        assert response is not None
-        assert "Python" in response
-
-    def test_anthropic_different_models(self):
-        """Test different Anthropic models."""
-        models = [
-            "claude-3-5-haiku-latest",
-            "claude-3-5-sonnet-latest",
-        ]
-
-        for model in models:
-            if "opus" in model and not os.getenv("TEST_EXPENSIVE_MODELS"):
-                continue  # Skip expensive models unless explicitly enabled
-
-            agent = Agent(
-                name=f"anthropic_{model.split('-')[2]}",
-                model=model
-            )
-
-            response = agent.input("Reply with OK")
-            assert response is not None
-            assert len(response) > 0
-
-    def test_anthropic_system_prompt(self):
-        """Test Anthropic with custom system prompt."""
-        agent = Agent(
-            name="anthropic_system",
-            model="claude-3-5-haiku-latest",
-            system_prompt="You are a helpful poetry assistant. Always respond in haiku format."
-        )
-
-        response = agent.input("Tell me about the weather")
-        assert response is not None
-        # Check it's attempting haiku format (3 lines, roughly)
-        lines = response.strip().split('\n')
-        assert len(lines) >= 1  # At least has content

tests/real_api/test_real_api.py

@@ -1,113 +0,0 @@
-#!/usr/bin/env python3
-"""Test with the actual deployed OpenOnion API."""
-
-import os
-import sys
-import requests
-from pathlib import Path
-from dotenv import load_dotenv
-
-# Load test environment
-env_path = Path(__file__).parent / '.env.test'
-if env_path.exists():
-    load_dotenv(env_path)
-
-def test_deployed_api():
-    """Test the actual deployed API endpoints."""
-    
-    print("\n" + "="*60)
-    print("🌐 TESTING DEPLOYED OPENONION API")
-    print("="*60)
-    
-    backend_url = "https://oo.openonion.ai"
-    
-    # Test 1: Health Check
-    print("\n✅ Testing health endpoint...")
-    response = requests.get(f"{backend_url}/health")
-    if response.status_code == 200:
-        data = response.json()
-        print(f"   Status: {data.get('status')}")
-        print(f"   Timestamp: {data.get('timestamp')}")
-    
-    # Test 2: Check available email endpoints
-    print("\n📋 Available email endpoints:")
-    endpoints = [
-        "/api/email/send",
-        "/api/email/webhook/incoming", 
-        "/api/email/tier",
-        "/api/email/upgrade",
-        "/api/email/received",  # Admin endpoint
-        "/api/emails",  # New endpoint (if deployed)
-        "/api/emails/mark-read"  # New endpoint (if deployed)
-    ]
-    
-    for endpoint in endpoints:
-        # Try OPTIONS request to check if endpoint exists
-        try:
-            response = requests.options(f"{backend_url}{endpoint}", timeout=2)
-            if response.status_code < 500:
-                print(f"   ✅ {endpoint} - Available")
-            else:
-                print(f"   ❌ {endpoint} - Server error")
-        except:
-            print(f"   ⚠️  {endpoint} - Not responding")
-    
-    # Test 3: Try to authenticate
-    print("\n🔐 Testing authentication...")
-    
-    # Note: The deployed API might not accept test signatures
-    auth_data = {
-        "public_key": os.getenv("TEST_PUBLIC_KEY"),
-        "message": "test_message",
-        "signature": "test_signature"
-    }
-    
-    response = requests.post(f"{backend_url}/auth", json=auth_data)
-    if response.status_code == 200:
-        print("   ✅ Authentication successful")
-        token = response.json().get("token")
-        if token:
-            print(f"   Token: {token[:30]}...")
-    else:
-        print(f"   ⚠️  Authentication failed: {response.status_code}")
-        if response.status_code == 400:
-            print("   Note: Test signatures not accepted in production")
-    
-    # Test 4: Check if new endpoints are deployed
-    print("\n🆕 Checking new email endpoints...")
-    
-    jwt_token = os.getenv("TEST_JWT_TOKEN")
-    headers = {
-        "Authorization": f"Bearer {jwt_token}",
-        "Content-Type": "application/json"
-    }
-    
-    # Try GET /api/emails
-    response = requests.get(f"{backend_url}/api/emails", headers=headers)
-    if response.status_code == 404:
-        print("   ℹ️  GET /api/emails - Not deployed yet")
-        print("   The new email inbox endpoints need to be deployed to production")
-    elif response.status_code == 200:
-        print("   ✅ GET /api/emails - Working!")
-        data = response.json()
-        print(f"   Emails: {len(data.get('emails', []))}")
-    else:
-        print(f"   ⚠️  GET /api/emails - Status: {response.status_code}")
-    
-    # Summary
-    print("\n" + "="*60)
-    print("📊 SUMMARY")
-    print("="*60)
-    print("\nThe deployed API has the following email capabilities:")
-    print("  ✅ Send emails via /api/email/send")
-    print("  ✅ Receive emails via webhook")
-    print("  ✅ Email tier management")
-    print("\nThe new inbox features (get_emails, mark_read) are:")
-    print("  ⚠️  Implemented locally but not yet deployed")
-    print("\nNext steps:")
-    print("  1. Deploy the updated oo-api with new endpoints")
-    print("  2. Test with real authentication flow")
-    print("  3. Verify email retrieval and marking as read")
-
-if __name__ == "__main__":
-    test_deployed_api()

tests/real_api/test_real_auth.py

@@ -1,130 +0,0 @@
-"""End-to-end test for ConnectOnion authentication with production API."""
-
-import time
-import json
-import requests
-from nacl.signing import SigningKey
-from nacl.encoding import HexEncoder
-
-def test_production_auth():
-    """Test authentication against production API."""
-    
-    # Generate test keys
-    signing_key = SigningKey.generate()
-    public_key = "0x" + signing_key.verify_key.encode(encoder=HexEncoder).decode()
-    
-    # Create ConnectOnion format message
-    timestamp = int(time.time())
-    message = f"ConnectOnion-Auth-{public_key}-{timestamp}"
-    
-    # Sign the message
-    signature = signing_key.sign(message.encode()).signature.hex()
-    
-    # Prepare request exactly as CLI does
-    payload = {
-        "public_key": public_key,
-        "message": message,
-        "signature": signature
-    }
-    
-    print("Testing Production API Authentication")
-    print("="*50)
-    print(f"Public Key: {public_key[:20]}...")
-    print(f"Message: {message[:50]}...")
-    print(f"Timestamp: {timestamp}")
-    
-    # Test against production API
-    api_url = "https://oo.openonion.ai/auth"
-    
-    try:
-        print(f"\nCalling: POST {api_url}")
-        response = requests.post(
-            api_url,
-            json=payload,
-            timeout=10,
-            headers={"Content-Type": "application/json"}
-        )
-        
-        print(f"Response Status: {response.status_code}")
-        
-        if response.status_code == 200:
-            data = response.json()
-            print("✅ Authentication successful!")
-            print(f"   Token: {data.get('token', '')[:20]}...")
-            print(f"   Public Key Confirmed: {data.get('public_key', '')[:20]}...")
-            
-            # Test token validation
-            if 'token' in data:
-                validate_url = "https://oo.openonion.ai/api/validate"
-                val_response = requests.get(
-                    validate_url,
-                    headers={"Authorization": f"Bearer {data['token']}"},
-                    timeout=5
-                )
-                if val_response.status_code == 200:
-                    print("✅ Token validation successful!")
-                else:
-                    print(f"⚠️  Token validation failed: {val_response.status_code}")
-            
-            return True
-        else:
-            print(f"❌ Authentication failed: {response.status_code}")
-            print(f"   Response: {response.text[:200]}")
-            return False
-            
-    except requests.exceptions.ConnectionError as e:
-        print(f"❌ Connection failed: {e}")
-        return False
-    except Exception as e:
-        print(f"❌ Unexpected error: {e}")
-        return False
-
-
-def test_llm_models_endpoint():
-    """Test that LLM models endpoint is accessible."""
-    
-    print("\n\nTesting LLM Models Endpoint")
-    print("="*50)
-    
-    api_url = "https://oo.openonion.ai/api/llm/models"
-    
-    try:
-        response = requests.get(api_url, timeout=5)
-        print(f"Response Status: {response.status_code}")
-        
-        if response.status_code == 200:
-            data = response.json()
-            models = data.get("models", [])
-            print(f"✅ Found {len(models)} models")
-            
-            # Check for co/ models
-            co_models = [m for m in models if m.get("id", "").startswith("co/")]
-            if co_models:
-                print(f"   Co/ models available: {len(co_models)}")
-                for model in co_models[:3]:  # Show first 3
-                    print(f"     - {model.get('id')}: {model.get('name')}")
-            return True
-        else:
-            print(f"❌ Failed to get models: {response.status_code}")
-            return False
-            
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    print("ConnectOnion <-> OpenOnion Production API Test\n")
-    
-    auth_ok = test_production_auth()
-    models_ok = test_llm_models_endpoint()
-    
-    print("\n" + "="*50)
-    print("Test Results:")
-    print(f"  Authentication: {'✅ PASSED' if auth_ok else '❌ FAILED'}")
-    print(f"  LLM Models: {'✅ PASSED' if models_ok else '❌ FAILED'}")
-    
-    if auth_ok and models_ok:
-        print("\n🎉 All tests passed! Integration is working.")
-    else:
-        print("\n⚠️  Some tests failed. Check the logs above.")

tests/real_api/test_real_email.py

@@ -1,95 +0,0 @@
-#!/usr/bin/env python3
-"""Test email functionality with live backend - uses environment variables safely."""
-
-import os
-import sys
-from pathlib import Path
-
-# Add parent to path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from connectonion import send_email, get_emails, mark_read
-from tests.utils.config_helpers import ProjectHelper
-
-
-def test_live_email():
-    """Test with deployed backend using environment variables."""
-    
-    print("\n🧪 Live Email Test")
-    print("=" * 50)
-    
-    # Use environment variables - NEVER hardcode credentials!
-    backend_url = os.getenv("CONNECTONION_BACKEND_URL", "https://oo.openonion.ai")
-    
-    # Check if we have required environment variables
-    if not os.getenv("OPENAI_API_KEY"):
-        print("⚠️  Please set OPENAI_API_KEY environment variable")
-        print("   export OPENAI_API_KEY=your-key-here")
-        return
-    
-    print(f"🌐 Using backend: {backend_url}")
-
-    with ProjectHelper() as project_dir:
-        print(f"📁 Test project: {project_dir}")
-        
-        # The test project already has the test account configured
-        # Now test the functionality
-        
-        # Test 1: Check current inbox
-        print("\n📥 Checking inbox...")
-        emails = get_emails()
-        
-        if emails:
-            print(f"✅ Found {len(emails)} emails")
-            for i, email in enumerate(emails[:3], 1):
-                print(f"\n   Email {i}:")
-                print(f"     From: {email.get('from')}")
-                print(f"     Subject: {email.get('subject')}")
-                print(f"     Read: {email.get('read')}")
-        else:
-            print("📭 No emails in inbox")
-        
-        # Test 2: Send a test email
-        print("\n📤 Sending test email...")
-        result = send_email(
-            to="test@example.com",
-            subject="Test from ConnectOnion",
-            message="This is a test email sent via the ConnectOnion API"
-        )
-        
-        if result.get("success"):
-            print(f"✅ Email sent successfully!")
-            print(f"   Message ID: {result.get('message_id')}")
-            print(f"   From: {result.get('from')}")
-        else:
-            print(f"⚠️  Send failed: {result.get('error')}")
-        
-        # Test 3: Mark emails as read
-        if emails and len(emails) > 0:
-            unread = [e for e in emails if not e.get('read')]
-            if unread:
-                print(f"\n✔️  Marking {len(unread)} emails as read...")
-                for email in unread[:3]:  # Mark up to 3
-                    success = mark_read(email['id'])
-                    if success:
-                        print(f"   ✅ Marked {email['id']} as read")
-                    else:
-                        print(f"   ⚠️  Failed to mark {email['id']}")
-        
-        print("\n" + "=" * 50)
-        print("✅ Test completed")
-        print("\n⚠️  Remember: NEVER commit API keys to version control!")
-
-
-if __name__ == "__main__":
-    # Safety check
-    if len(sys.argv) > 1 and sys.argv[1] == "--confirm":
-        test_live_email()
-    else:
-        print("⚠️  This test connects to the live backend.")
-        print("   Run with --confirm flag to proceed:")
-        print("   python test_email_live.py --confirm")
-        print("\n📝 Required environment variables:")
-        print("   - OPENAI_API_KEY")
-        print("   - CONNECTONION_BACKEND_URL (optional)")
-        print("\n🔒 Security: Use environment variables, never hardcode keys!")

tests/real_api/test_real_gemini.py

@@ -1,96 +0,0 @@
-"""
-Real Google Gemini API tests.
-
-These tests make actual API calls to Google Gemini and cost real money.
-Run with: pytest test_real_gemini.py -v
-
-Requires: GEMINI_API_KEY environment variable (GOOGLE_API_KEY also supported for backward compatibility)
-"""
-
-import os
-import pytest
-from pathlib import Path
-from dotenv import load_dotenv
-from connectonion import Agent
-from connectonion.llm import GeminiLLM
-
-# Load environment variables from tests/.env
-env_path = Path(__file__).parent / ".env"
-if env_path.exists():
-    load_dotenv(env_path)
-
-
-def word_counter(text: str) -> str:
-    """Count words in text for testing."""
-    words = text.split()
-    return f"Word count: {len(words)}"
-
-
-class TestRealGemini:
-    """Test real Google Gemini API integration."""
-
-    def test_gemini_basic_completion(self):
-        """Test basic completion with Gemini."""
-        api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
-        llm = GeminiLLM(api_key=api_key, model="gemini-2.5-pro")
-        agent = Agent(name="gemini_test", llm=llm)
-
-        response = agent.input("Say 'Hello from Gemini' exactly")
-        assert response is not None
-        assert "Hello from Gemini" in response
-
-    def test_gemini_with_tools(self):
-        """Test Gemini with tool calling."""
-        agent = Agent(
-            name="gemini_tools",
-            model="gemini-2.5-pro",
-            tools=[word_counter]
-        )
-
-        response = agent.input("Count the words in 'The quick brown fox'")
-        assert response is not None
-        assert "4" in response or "four" in response.lower()
-
-    def test_gemini_multi_turn(self):
-        """Test multi-turn conversation with Gemini."""
-        agent = Agent(
-            name="gemini_conversation",
-            model="gemini-2.5-pro"
-        )
-
-        # First turn
-        response = agent.input("My favorite color is blue. Remember this.")
-        assert response is not None
-
-        # Second turn - should remember context
-        response = agent.input("What's my favorite color?")
-        assert response is not None
-        assert "blue" in response.lower()
-
-    def test_gemini_different_models(self):
-        """Test different Gemini models."""
-        models = ["gemini-2.5-pro", "gemini-2.5-flash"]
-
-        for model in models:
-
-            api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
-            agent = Agent(
-                name=f"gemini_{model.replace('.', '_').replace('-', '_')}",
-                llm=GeminiLLM(api_key=api_key, model=model)
-            )
-
-            response = agent.input("Reply with OK")
-            assert response is not None
-            assert len(response) > 0
-
-    def test_gemini_system_prompt(self):
-        """Test Gemini with custom system prompt."""
-        agent = Agent(
-            name="gemini_system",
-            model="gemini-2.5-pro",
-            system_prompt="You are a helpful math tutor. Always explain your reasoning step by step."
-        )
-
-        response = agent.input("What is 2 + 2?")
-        assert response is not None
-        assert "4" in response or "four" in response.lower()