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

tests/test_gemini_co.py

@@ -1,70 +0,0 @@
-"""Test Gemini models via direct API and co/ managed keys"""
-import os
-import pytest
-from connectonion import Agent, llm_do
-
-# Set Gemini API key for direct tests
-os.environ.setdefault('GEMINI_API_KEY', 'AIzaSyCMBM2LTb-5AYtrjMa1xfPdqj8NNSH9F34')
-
-
-@pytest.mark.real_api
-def test_gemini_flash_direct():
-    """Test Gemini 2.5 Flash via direct API"""
-    agent = Agent(
-        name="test-gemini-direct",
-        model="gemini-2.5-flash"  # Direct, no co/ prefix
-    )
-    response = agent.input("Say hello in one word")
-    assert response, "No response from Gemini Flash"
-    print(f"Gemini Flash response: {response}")
-
-
-@pytest.mark.real_api
-def test_gemini_pro_direct():
-    """Test Gemini 2.5 Pro via direct API"""
-    agent = Agent(
-        name="test-gemini-pro-direct",
-        model="gemini-2.5-pro"  # Direct, no co/ prefix
-    )
-    response = agent.input("What is 2+2? Just the number.")
-    assert response, "No response from Gemini Pro"
-    print(f"Gemini Pro response: {response}")
-
-
-@pytest.mark.real_api
-def test_llm_do_gemini_direct():
-    """Test llm_do with Gemini model via direct API"""
-    result = llm_do("Say hi", model="gemini-2.5-flash")
-    assert result, "No result from llm_do with Gemini"
-    print(f"llm_do Gemini result: {result}")
-
-
-@pytest.mark.real_api
-@pytest.mark.skip(reason="Requires co/ account with credits")
-def test_gemini_flash_via_co():
-    """Test Gemini 2.5 Flash via co/ managed keys"""
-    agent = Agent(
-        name="test-gemini-co",
-        model="co/gemini-2.5-flash"
-    )
-    response = agent.input("Say hello in one word")
-    assert response, "No response from Gemini Flash"
-    print(f"Gemini Flash (co/) response: {response}")
-
-
-if __name__ == "__main__":
-    print("Testing Gemini models...")
-
-    print("\n1. Testing Gemini Flash (direct API)...")
-    test_gemini_flash_direct()
-    print("   ✓ Passed")
-
-    print("\n2. Testing Gemini Pro (direct API)...")
-    test_gemini_pro_direct()
-    print("   ✓ Passed")
-
-    print("\n3. Testing llm_do with Gemini (direct API)...")
-    test_llm_do_gemini_direct()
-    print("   ✓ Passed")
-
-    print("\n✅ All Gemini tests passed!")

tests/test_image_result_formatter.py

@@ -1,88 +0,0 @@
-"""Tests for image_result_formatter plugin"""
-
-import pytest
-from connectonion.useful_plugins.image_result_formatter import _is_base64_image
-
-
-class TestIsBase64Image:
-    """Test base64 image detection logic"""
-
-    def test_data_url_png(self):
-        """Should detect PNG data URL"""
-        # Tiny 1x1 red PNG
-        data_url = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg=="
-
-        is_img, mime, data = _is_base64_image(data_url)
-
-        assert is_img is True
-        assert mime == "image/png"
-        assert data == "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg=="
-
-    def test_data_url_jpeg(self):
-        """Should detect JPEG data URL"""
-        data_url = "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAIBAQIBAQICAgICAgICAwUDAwMDAwYEBAMFBwYHBw=="
-
-        is_img, mime, data = _is_base64_image(data_url)
-
-        assert is_img is True
-        assert mime == "image/jpeg"
-        assert "/9j/4AAQSkZJRgABAQEAYABgAAD" in data
-
-    def test_data_url_in_mixed_content(self):
-        """Should detect data URL even when mixed with other text"""
-        mixed = "Screenshot saved! Here's the data: data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg=="
-
-        is_img, mime, data = _is_base64_image(mixed)
-
-        assert is_img is True
-        assert mime == "image/png"
-
-    def test_long_plain_base64(self):
-        """Should detect long plain base64 string (>100 chars)"""
-        # Create a base64 string longer than 100 characters
-        long_base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==" * 2
-
-        is_img, mime, data = _is_base64_image(long_base64)
-
-        assert is_img is True
-        assert mime == "image/png"  # Defaults to PNG
-        assert data == long_base64.strip()
-
-    def test_short_base64_not_detected(self):
-        """Should NOT detect short base64-like strings (<100 chars)"""
-        short_base64 = "ABC123DEF456GHI789"
-
-        is_img, mime, data = _is_base64_image(short_base64)
-
-        assert is_img is False
-
-    def test_regular_text_not_detected(self):
-        """Should NOT detect regular text"""
-        text = "This is just regular text, not an image at all"
-
-        is_img, mime, data = _is_base64_image(text)
-
-        assert is_img is False
-
-    def test_non_string_input(self):
-        """Should handle non-string input gracefully"""
-        is_img, mime, data = _is_base64_image(123)
-
-        assert is_img is False
-        assert mime == ""
-        assert data == ""
-
-    def test_empty_string(self):
-        """Should handle empty string"""
-        is_img, mime, data = _is_base64_image("")
-
-        assert is_img is False
-
-    def test_webp_data_url(self):
-        """Should detect WebP data URL"""
-        data_url = "data:image/webp;base64,UklGRiQAAABXRUJQVlA4IBgAAAAwAQCdASoBAAEAAwA0JaQAA3AA/vuUAAA="
-
-        is_img, mime, data = _is_base64_image(data_url)
-
-        assert is_img is True
-        assert mime == "image/webp"

tests/test_plugin_system.py

@@ -1,110 +0,0 @@
-"""Test the plugin system implementation."""
-from connectonion import Agent, after_llm, after_tool
-
-# Simple plugin - just a list
-def log_llm(agent):
-    pass  # Just a marker
-
-simple_logger = [after_llm(log_llm)]
-
-
-# Plugin factory for configuration
-def make_counter():
-    """Create a counter plugin with state."""
-    counts = {'llm': 0, 'tool': 0}
-
-    def count_llm(agent):
-        counts['llm'] += 1
-
-    def count_tool(agent):
-        counts['tool'] += 1
-
-    return [
-        after_llm(count_llm),
-        after_tool(count_tool)
-    ]
-
-
-def test_simple_plugin():
-    """Test that simple list plugins register correctly."""
-    agent = Agent(
-        "test_simple",
-        plugins=[simple_logger],  # Pass the list directly
-        log=False
-    )
-
-    # Should have 1 after_llm event handler
-    assert len(agent.events['after_llm']) == 1
-    # Total events should be 1
-    total_events = sum(len(handlers) for handlers in agent.events.values())
-    assert total_events == 1
-
-
-def test_factory_plugin():
-    """Test that plugin factories work for configuration."""
-    counter = make_counter()  # Create the list
-    agent = Agent(
-        "test_factory",
-        plugins=[counter],  # Pass the list
-        log=False
-    )
-
-    # Should have 1 after_llm and 1 after_tool handler
-    assert len(agent.events['after_llm']) == 1
-    assert len(agent.events['after_tool']) == 1
-    # Total events should be 2
-    total_events = sum(len(handlers) for handlers in agent.events.values())
-    assert total_events == 2
-
-
-def test_multiple_plugins():
-    """Test that multiple plugins can be registered together."""
-    counter = make_counter()
-    agent = Agent(
-        "test_multiple",
-        plugins=[simple_logger, counter],  # Two lists
-        log=False
-    )
-
-    # Should have 2 after_llm handlers (one from each plugin)
-    assert len(agent.events['after_llm']) == 2
-    # Should have 1 after_tool handler (from counter)
-    assert len(agent.events['after_tool']) == 1
-    # Total events should be 3
-    total_events = sum(len(handlers) for handlers in agent.events.values())
-    assert total_events == 3
-
-
-def test_plugins_with_on_events():
-    """Test that plugins and on_events can be used together."""
-    def custom_event(agent):
-        pass
-
-    agent = Agent(
-        "test_combined",
-        plugins=[simple_logger],
-        on_events=[after_tool(custom_event)],
-        log=False
-    )
-
-    # Should have 1 after_llm from plugin
-    assert len(agent.events['after_llm']) == 1
-    # Should have 1 after_tool from on_events
-    assert len(agent.events['after_tool']) == 1
-    # Total events should be 2
-    total_events = sum(len(handlers) for handlers in agent.events.values())
-    assert total_events == 2
-
-
-def test_reusable_plugin():
-    """Test that plugins can be reused across multiple agents."""
-    # Create plugin once
-    counter = make_counter()
-
-    # Use it in multiple agents
-    agent1 = Agent("test1", plugins=[counter], log=False)
-    agent2 = Agent("test2", plugins=[counter], log=False)
-
-    # Both should have the same events
-    assert len(agent1.events['after_llm']) == 1
-    assert len(agent2.events['after_llm']) == 1

tests/utils/__init__.py

@@ -1 +0,0 @@
-"""Test utilities package."""

tests/utils/config_helpers.py

@@ -1,188 +0,0 @@
-"""Test configuration for ConnectOnion tests."""
-
-import os
-from pathlib import Path
-
-# Fixed test account details
-TEST_ACCOUNT = {
-    "public_key": "04e1c4ae3c57d716383153479dae869e51e86d43d88db8dfa22fba7533f3968d",
-    "private_key": "test_private_key_do_not_use_in_production",
-    "address": "0x04e1c4ae3c57d716383153479dae869e51e86d43d88db8dfa22fba7533f3968d",
-    "short_address": "0x04e1c4ae",
-    "email": "0x04e1c4ae@mail.openonion.ai",
-    "email_active": True
-}
-
-# Test JWT token (for testing only, not valid for production)
-TEST_JWT_TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwdWJsaWNfa2V5IjoiMDRlMWM0YWUzYzU3ZDcxNjM4MzE1MzQ3OWRhZTg2OWU1MWU4NmQ0M2Q4OGRiOGRmYTIyZmJhNzUzM2YzOTY4ZCIsImV4cCI6OTk5OTk5OTk5OX0.test_signature"
-
-# Test backend URL - defaults to production for real API tests
-TEST_BACKEND_URL = os.getenv("TEST_BACKEND_URL", "https://oo.openonion.ai")
-
-# Test configuration for .co directory
-TEST_CONFIG_TOML = {
-    "project": {
-        "name": "test-project",
-        "created": "2024-01-01T00:00:00",
-        "framework_version": "0.0.5",
-    },
-    "cli": {
-        "version": "1.0.0",
-        "command": "co init",
-        "template": "test",
-    },
-    "agent": {
-        "address": TEST_ACCOUNT["address"],
-        "short_address": TEST_ACCOUNT["short_address"],
-        "email": TEST_ACCOUNT["email"],
-        "email_active": TEST_ACCOUNT["email_active"],
-        "created_at": "2024-01-01T00:00:00",
-        "algorithm": "ed25519",
-        "default_model": "gpt-4o-mini",
-        "max_iterations": 10,
-    },
-    "auth": {
-        "token": TEST_JWT_TOKEN,
-        "public_key": TEST_ACCOUNT["public_key"],
-        "authenticated_at": "2024-01-01T00:00:00"
-    }
-}
-
-# Sample test emails
-SAMPLE_EMAILS = [
-    {
-        "id": "msg_test_001",
-        "from": "alice@example.com",
-        "subject": "Test Email 1",
-        "message": "This is test email number 1",
-        "timestamp": "2024-01-15T10:00:00Z",
-        "read": False
-    },
-    {
-        "id": "msg_test_002",
-        "from": "bob@example.com",
-        "subject": "Test Email 2",
-        "message": "This is test email number 2",
-        "timestamp": "2024-01-15T11:00:00Z",
-        "read": True
-    },
-    {
-        "id": "msg_test_003",
-        "from": "charlie@example.com",
-        "subject": "Urgent: Test Email 3",
-        "message": "This is an urgent test email",
-        "timestamp": "2024-01-15T12:00:00Z",
-        "read": False
-    }
-]
-
-
-def create_test_project(base_dir: Path = None) -> Path:
-    """Create a test ConnectOnion project with fixed test account.
-    
-    Args:
-        base_dir: Base directory to create project in. Uses temp dir if None.
-        
-    Returns:
-        Path to the created project directory
-    """
-    import tempfile
-    import toml
-    
-    if base_dir is None:
-        base_dir = Path(tempfile.mkdtemp(prefix="co_test_"))
-    else:
-        base_dir = Path(base_dir)
-        base_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Create .co directory structure
-    co_dir = base_dir / ".co"
-    co_dir.mkdir(exist_ok=True)
-    
-    keys_dir = co_dir / "keys"
-    keys_dir.mkdir(exist_ok=True)
-    
-    # Write test config
-    config_path = co_dir / "config.toml"
-    with open(config_path, "w") as f:
-        toml.dump(TEST_CONFIG_TOML, f)
-    
-    # Write test keys (for testing only)
-    public_key_path = keys_dir / "public_key.txt"
-    public_key_path.write_text(TEST_ACCOUNT["public_key"])
-    
-    private_key_path = keys_dir / "private_key.txt"
-    private_key_path.write_text(TEST_ACCOUNT["private_key"])
-    
-    # Create a sample agent.py
-    agent_file = base_dir / "agent.py"
-    agent_file.write_text("""#!/usr/bin/env python3
-\"\"\"Test agent for ConnectOnion.\"\"\"
-
-from connectonion import Agent, send_email, get_emails, mark_read
-
-def main():
-    agent = Agent(
-        "test-agent",
-        tools=[send_email, get_emails, mark_read],
-        model="gpt-4o-mini"
-    )
-    
-    # Test email functionality
-    emails = get_emails()
-    print(f"Found {len(emails)} emails")
-    
-    for email in emails[:3]:
-        print(f"- {email['from']}: {email['subject']}")
-
-if __name__ == "__main__":
-    main()
-""")
-    
-    # Don't create a fake .env - use environment variables from tests/.env
-    # The tests/.env file is loaded by the module-level load_dotenv in __init__.py
-    # and re-loaded by ProjectHelper.__enter__() to ensure test env vars are available
-    
-    return base_dir
-
-
-def cleanup_test_project(project_dir: Path):
-    """Clean up a test project directory.
-    
-    Args:
-        project_dir: Path to the project directory to clean up
-    """
-    import shutil
-    
-    if project_dir.exists() and ".co" in os.listdir(project_dir):
-        shutil.rmtree(project_dir)
-
-
-# Context manager for test projects
-class ProjectHelper:
-    """Context manager for creating and cleaning up test projects."""
-    
-    def __init__(self, base_dir: Path = None):
-        self.base_dir = base_dir
-        self.project_dir = None
-        self.original_cwd = None
-    
-    def __enter__(self):
-        import os
-        from dotenv import load_dotenv
-        from pathlib import Path
-        self.original_cwd = os.getcwd()
-        self.project_dir = create_test_project(self.base_dir)
-        os.chdir(self.project_dir)
-        # Load environment variables from tests/.env
-        # This ensures real API keys are available for integration tests
-        tests_env = Path(__file__).parent.parent / ".env"
-        if tests_env.exists():
-            load_dotenv(tests_env, override=True)
-        return self.project_dir
-    
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        import os
-        os.chdir(self.original_cwd)
-        if self.project_dir and self.project_dir.exists():
-            cleanup_test_project(self.project_dir)

tests/utils/mock_helpers.py

@@ -1,237 +0,0 @@
-"""Mock helpers for ConnectOnion testing."""
-
-import json
-from unittest.mock import Mock, MagicMock
-from typing import Dict, List, Any, Optional
-from connectonion.llm import LLMResponse, ToolCall
-from connectonion.usage import TokenUsage
-
-
-class OpenAIMockBuilder:
-    """Builder for creating OpenAI API mocks."""
-
-    @staticmethod
-    def simple_response(content: str, model: str = "gpt-3.5-turbo") -> Mock:
-        """Create mock for text-only responses."""
-        mock_response = MagicMock()
-        mock_response.id = "chatcmpl-test123"
-        mock_response.object = "chat.completion"
-        mock_response.model = model
-        mock_response.choices = [MagicMock()]
-        mock_response.choices[0].message.content = content
-        mock_response.choices[0].message.tool_calls = None
-        mock_response.choices[0].finish_reason = "stop"
-        return mock_response
-
-    @staticmethod
-    def tool_call_response(
-        tool_name: str,
-        arguments: Dict[str, Any],
-        call_id: str = "call_test123"
-    ) -> Mock:
-        """Create mock for tool calling responses."""
-        mock_response = MagicMock()
-        mock_response.id = "chatcmpl-test456"
-        mock_response.object = "chat.completion"
-        mock_response.choices = [MagicMock()]
-        mock_response.choices[0].message.content = None
-
-        # Create tool call mock
-        tool_call = MagicMock()
-        tool_call.id = call_id
-        tool_call.type = "function"
-        tool_call.function.name = tool_name
-        tool_call.function.arguments = json.dumps(arguments)
-
-        mock_response.choices[0].message.tool_calls = [tool_call]
-        mock_response.choices[0].finish_reason = "tool_calls"
-        return mock_response
-
-    @staticmethod
-    def error_response(error_type: str, message: str) -> Exception:
-        """Create mock for API errors."""
-        from openai import APIError, RateLimitError, AuthenticationError
-
-        error_map = {
-            "rate_limit": RateLimitError,
-            "auth": AuthenticationError,
-            "api": APIError
-        }
-
-        error_class = error_map.get(error_type, APIError)
-        return error_class(
-            message=message,
-            response=MagicMock(),
-            body={"error": {"message": message}}
-        )
-
-    @staticmethod
-    def multi_response_sequence(responses: List[Dict[str, Any]]) -> List[Mock]:
-        """Create sequence of mock responses for side_effect."""
-        mock_responses = []
-
-        for response_data in responses:
-            if response_data.get("type") == "text":
-                mock_responses.append(
-                    OpenAIMockBuilder.simple_response(response_data["content"])
-                )
-            elif response_data.get("type") == "tool_call":
-                mock_responses.append(
-                    OpenAIMockBuilder.tool_call_response(
-                        response_data["tool_name"],
-                        response_data["arguments"],
-                        response_data.get("call_id", "call_test")
-                    )
-                )
-            elif response_data.get("type") == "error":
-                mock_responses.append(
-                    OpenAIMockBuilder.error_response(
-                        response_data["error_type"],
-                        response_data["message"]
-                    )
-                )
-
-        return mock_responses
-
-
-class LLMResponseBuilder:
-    """Builder for creating LLMResponse objects."""
-
-    @staticmethod
-    def text_response(content: str) -> LLMResponse:
-        """Create text-only LLMResponse."""
-        return LLMResponse(
-            content=content,
-            tool_calls=[],
-            raw_response=None,
-            usage=TokenUsage(),
-        )
-
-    @staticmethod
-    def tool_call_response(
-        tool_name: str,
-        arguments: Dict[str, Any],
-        call_id: str = "call_test"
-    ) -> LLMResponse:
-        """Create tool calling LLMResponse."""
-        tool_call = ToolCall(
-            name=tool_name,
-            arguments=arguments,
-            id=call_id
-        )
-
-        return LLMResponse(
-            content=None,
-            tool_calls=[tool_call],
-            raw_response=None,
-            usage=TokenUsage(),
-        )
-
-    @staticmethod
-    def multi_tool_response(tool_calls: List[Dict[str, Any]]) -> LLMResponse:
-        """Create multi-tool calling LLMResponse."""
-        calls = []
-        for i, call_data in enumerate(tool_calls):
-            calls.append(ToolCall(
-                name=call_data["name"],
-                arguments=call_data["arguments"],
-                id=call_data.get("id", f"call_test_{i}")
-            ))
-
-        return LLMResponse(
-            content=None,
-            tool_calls=calls,
-            raw_response=None,
-            usage=TokenUsage(),
-        )
-
-
-class FileSystemMocker:
-    """Mock file system operations."""
-
-    @staticmethod
-    def create_mock_file_error(error_type: str, message: str = None):
-        """Create file system error mocks."""
-        error_map = {
-            "not_found": FileNotFoundError,
-            "permission": PermissionError,
-            "disk_full": OSError
-        }
-
-        error_class = error_map.get(error_type, OSError)
-        default_messages = {
-            "not_found": "File not found",
-            "permission": "Permission denied",
-            "disk_full": "No space left on device"
-        }
-
-        error_message = message or default_messages.get(error_type, "File system error")
-        return error_class(error_message)
-
-
-class AgentWorkflowMocker:
-    """Mock complex agent workflows."""
-
-    @staticmethod
-    def calculator_workflow():
-        """Mock a calculator workflow sequence."""
-        return [
-            LLMResponseBuilder.tool_call_response(
-                "calculator",
-                {"expression": "2 + 2"}
-            ),
-            LLMResponseBuilder.text_response("The result is 4.")
-        ]
-
-    @staticmethod
-    def multi_tool_workflow():
-        """Mock a multi-tool workflow sequence."""
-        return [
-            LLMResponseBuilder.tool_call_response(
-                "calculator",
-                {"expression": "100 / 4"}
-            ),
-            LLMResponseBuilder.tool_call_response(
-                "current_time",
-                {}
-            ),
-            LLMResponseBuilder.text_response(
-                "The result is 25.0, calculated at the current time."
-            )
-        ]
-
-    @staticmethod
-    def error_recovery_workflow():
-        """Mock a workflow with error recovery."""
-        return [
-            LLMResponseBuilder.tool_call_response(
-                "calculator",
-                {"expression": "invalid"}  # This will cause an error
-            ),
-            LLMResponseBuilder.text_response(
-                "I apologize for the error. Let me try a valid calculation."
-            ),
-            LLMResponseBuilder.tool_call_response(
-                "calculator",
-                {"expression": "2 + 2"}
-            ),
-            LLMResponseBuilder.text_response("The result is 4.")
-        ]
-
-
-# Convenience functions for common scenarios
-def create_successful_agent_mock(responses: List[str]) -> Mock:
-    """Create a mock agent that returns successful text responses."""
-    mock_agent = Mock()
-    mock_agent.run.side_effect = responses
-    mock_agent.name = "test_agent"
-    mock_agent.list_tools.return_value = ["calculator", "current_time"]
-    return mock_agent
-
-
-def create_failing_agent_mock(error_message: str = "Agent error") -> Mock:
-    """Create a mock agent that fails."""
-    mock_agent = Mock()
-    mock_agent.run.side_effect = Exception(error_message)
-    mock_agent.name = "failing_agent"
-    return mock_agent