mito-ai 0.1.33__py3-none-any.whl → 0.1.49__py3-none-any.whl

mito_ai/app_builder/handlers.py

@@ -1,218 +0,0 @@
-# Copyright (c) Saga Inc.
-# Distributed under the terms of the GNU Affero General Public License v3.0 License.
-
-import os
-import time
-import logging
-from typing import Any, Union
-import zipfile
-import tempfile
-from mito_ai.utils.create import initialize_user
-from mito_ai.utils.websocket_base import BaseWebSocketHandler
-from mito_ai.app_builder.models import (
-    BuildAppReply,
-    AppBuilderError,
-    ErrorMessage,
-    MessageType
-)
-from mito_ai.logger import get_logger
-import requests
-
-# API endpoint for getting pre-signed URL
-API_BASE_URL = "https://fr12uvtfy5.execute-api.us-east-1.amazonaws.com"
-
-class AppBuilderHandler(BaseWebSocketHandler):
-    """Handler for app building requests."""
-    
-    def initialize(self) -> None:
-        """Initialize the WebSocket handler."""
-        super().initialize()
-        self.log.debug("Initializing app builder websocket connection %s", self.request.path)
-    
-    @property
-    def log(self) -> logging.Logger:
-        """Use Mito AI logger."""
-        return get_logger()
-    
-    async def get(self, *args: Any, **kwargs: Any) -> None:
-        """Get an event to open a socket or check service availability."""
-        # Check if this is just a service availability check
-        if self.get_query_argument('check_availability', None) == 'true':
-            self.set_status(200)
-            self.finish()
-            return
-
-        await super().pre_get()  # Authenticate and authorize
-        initialize_user()  # Initialize user directory structure
-        
-        reply = super().get(*args, **kwargs)
-        if reply is not None:
-            await reply
-    
-    async def on_message(self, message: Union[str, bytes]) -> None:
-        """Handle incoming messages on the WebSocket.
-        
-        Args:
-            message: The message received on the WebSocket.
-        """
-        start = time.time()
-        
-        # Convert bytes to string if needed
-        if isinstance(message, bytes):
-            message = message.decode('utf-8')
-        
-        self.log.debug("App builder message received: %s", message)
-        
-        try:
-            parsed_message = self.parse_message(message)
-            message_type = parsed_message.get('type')
-            
-            if message_type == MessageType.BUILD_APP.value:
-                # Handle build app request
-                await self._handle_build_app(parsed_message)
-            else:
-                self.log.error(f"Unknown message type: {message_type}")
-                error = AppBuilderError(
-                    error_type="InvalidRequest",
-                    title=f"Unknown message type: {message_type}"
-                )
-                self.reply(ErrorMessage(**error.__dict__))
-                
-        except ValueError as e:
-            self.log.error("Invalid app builder request", exc_info=e)
-            error = AppBuilderError.from_exception(e)
-            self.reply(ErrorMessage(**error.__dict__))
-        except Exception as e:
-            self.log.error("Error handling app builder message", exc_info=e)
-            error = AppBuilderError.from_exception(
-                e, 
-                hint="An error occurred while building the app. Please check the logs for details."
-            )
-            self.reply(ErrorMessage(**error.__dict__))
-            
-        latency_ms = round((time.time() - start) * 1000)
-        self.log.info(f"App builder handler processed in {latency_ms} ms.")
-    
-    async def _handle_build_app(self, message: dict) -> None:
-        """Handle a build app request.
-        
-        Args:
-            message: The parsed message.
-        """
-        message_id = message.get('message_id', '')  # Default to empty string if not present
-        app_path = message.get('path')
-        
-        if not message_id:
-            self.log.error("Missing message_id in request")
-            return
-        
-        if not app_path:
-            error = AppBuilderError(
-                error_type="InvalidRequest",
-                title="Missing 'path' parameter"
-            )
-            self.reply(BuildAppReply(
-                parent_id=message_id,
-                url="",
-                error=error
-            ))
-            return
-        
-        try:
-            # This is a placeholder for the actual app building logic
-            # In a real implementation, this would deploy the app to a hosting service
-            # and return the URL
-            deploy_url = await self._deploy_app(app_path)
-            
-            # Send the response
-            self.reply(BuildAppReply(
-                parent_id=message_id,
-                url=deploy_url
-            ))
-            
-        except Exception as e:
-            self.log.error(f"Error building app: {e}", exc_info=e)
-            error = AppBuilderError.from_exception(e)
-            self.reply(BuildAppReply(
-                parent_id=message_id,
-                url="",
-                error=error
-            ))
-    
-    async def _deploy_app(self, app_path: str) -> str:
-        """Deploy the app using pre-signed URLs.
-        
-        Args:
-            app_path: Path to the app file.
-            
-        Returns:
-            The URL of the deployed app.
-        """
-        # Get app name from the path
-        app_name = os.path.basename(app_path).split('.')[0]
-        self.log.info(f"Deploying app: {app_name} from path: {app_path}")
-        
-        try:
-            # Step 1: Get pre-signed URL from API
-            self.log.info("Getting pre-signed upload URL...")
-            url_response = requests.get(f"{API_BASE_URL}/get-upload-url?app_name={app_name}")
-            url_response.raise_for_status()
-            
-            url_data = url_response.json()
-            presigned_url = url_data['upload_url']
-            expected_app_url = url_data['expected_app_url']
-            
-            self.log.info(f"Received pre-signed URL. App will be available at: {expected_app_url}")
-            
-            # Step 2: Create a zip file of the app.
-            temp_zip_path = None
-            try:
-                # Create temp file and close it before writing to avoid file handle conflicts
-                with tempfile.NamedTemporaryFile(suffix='.zip', delete=False) as temp_zip:
-                    temp_zip_path = temp_zip.name
-
-                self.log.info("Zipping application files...")
-                with zipfile.ZipFile(temp_zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
-                    for root, _, files in os.walk(app_path):
-                        for file in files:
-                            file_path = os.path.join(root, file)
-                            zipf.write(file_path, arcname=os.path.relpath(file_path, app_path))
-
-                upload_response = await self._upload_app_to_s3(temp_zip_path, presigned_url)
-            except Exception as e:
-                self.log.error(f"Error zipping app: {e}")
-                raise
-            finally:
-                # Clean up
-                if temp_zip_path is not None:
-                    os.remove(temp_zip_path)
-            
-            self.log.info(f"Upload successful! Status code: {upload_response.status_code}")
-            
-            self.log.info(f"Deployment initiated. App will be available at: {expected_app_url}")
-            return expected_app_url # type: ignore
-            
-        except requests.exceptions.RequestException as e:
-            self.log.error(f"Error during API request: {e}")
-            if hasattr(e, 'response') and e.response is not None:
-                try:
-                    error_detail = e.response.json()
-                    self.log.error(f"Server error details: {error_detail}")
-                except:
-                    self.log.error(f"Server response: {e.response.text}")
-            raise Exception(f"Deployment failed: {str(e)}")
-        except Exception as e:
-            self.log.error(f"Error during deployment: {str(e)}")
-            raise
-
-    async def _upload_app_to_s3(self, app_path: str, presigned_url: str) -> requests.Response:
-        """Upload the app to S3 using the presigned URL."""
-        with open(app_path, 'rb') as file_data:
-            upload_response = requests.put(
-                presigned_url,
-                data=file_data,
-                headers={'Content-Type': 'application/zip'}
-            )
-            upload_response.raise_for_status()
-            
-        return upload_response

mito_ai/tests/providers_test.py

@@ -1,438 +0,0 @@
-# Copyright (c) Saga Inc.
-# Distributed under the terms of the GNU Affero General Public License v3.0 License.
-
-from __future__ import annotations
-from datetime import datetime
-from typing import Any, List
-from unittest.mock import patch, MagicMock, AsyncMock
-
-import pytest
-from traitlets.config import Config
-from mito_ai.completions.providers import OpenAIProvider
-from mito_ai.completions.models import (
-    MessageType,
-    AICapabilities,
-    CompletionReply
-)
-from mito_ai.completions.providers import OpenAIProvider
-from mito_ai.completions.models import MessageType, AICapabilities
-from mito_ai.utils.server_limits import OS_MONTHLY_AI_COMPLETIONS_LIMIT
-from openai.types.chat import ChatCompletionMessageParam
-
-REALLY_OLD_DATE = "2020-01-01"
-TODAY = datetime.now().strftime("%Y-%m-%d")
-FAKE_API_KEY = "sk-1234567890"
-
-@pytest.fixture
-def provider_config() -> Config:
-    """Create a proper Config object for the OpenAIProvider."""
-    config = Config()
-    config.OpenAIProvider = Config()
-    config.OpenAIClient = Config()
-    return config
-
-@pytest.fixture(autouse=True)
-def reset_env_vars(monkeypatch: pytest.MonkeyPatch) -> None:
-    for var in [
-        "OPENAI_API_KEY", "CLAUDE_API_KEY",
-        "GEMINI_API_KEY", "OLLAMA_MODEL",
-        "AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_MODEL"
-    ]:
-        monkeypatch.delenv(var, raising=False)
-
-
-def patch_server_limits(is_pro: bool = False, completion_count: int = 1, first_date: str = TODAY) -> Any:
-    return patch.multiple(
-        "mito_ai.utils.server_limits",
-        get_chat_completion_count=MagicMock(return_value=completion_count),
-        get_first_completion_date=MagicMock(return_value=first_date),
-        is_pro=MagicMock(return_value=is_pro),
-        check_mito_server_quota=MagicMock(return_value=None)
-    )
-
-
-def patch_openai_model_list() -> Any:
-    mock_openai_instance = MagicMock()
-    mock_openai_instance.models.list.return_value = [MagicMock(id="gpt-4o-mini")]
-
-    # Patch the constructor call to return your mock instance
-    return patch("openai.OpenAI", return_value=mock_openai_instance)
-
-
-def mock_openai_client() -> Any:
-    """Mock the OpenAI client with user key capabilities."""
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "gpt-4o-mini"},
-        provider="OpenAI with user key",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "user"
-    mock_client.request_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_completions = AsyncMock(return_value="Test completion")
-    return patch("mito_ai.completions.providers.OpenAIClient", return_value=mock_client)
-
-
-def mock_gemini_client() -> Any:
-    """Mock the Gemini client capabilities."""
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "gemini-2-pro"},
-        provider="Gemini",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "gemini"
-    mock_client.request_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_completions = AsyncMock(return_value="Test completion")
-    return patch("mito_ai.completions.providers.GeminiClient", return_value=mock_client)
-
-
-def mock_azure_openai_client() -> Any:
-    """Mock the Azure OpenAI client capabilities."""
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "gpt-4o"},
-        provider="Azure OpenAI",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "azure"
-    mock_client.request_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_completions = AsyncMock(return_value="Test completion")
-    return patch("mito_ai.completions.providers.OpenAIClient", return_value=mock_client)
-
-
-
-def mock_claude_client() -> Any:
-    """Mock the Claude client capabilities."""
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "claude-3-opus-20240229"},
-        provider="Claude",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "claude"
-    mock_client.request_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_response = AsyncMock(return_value="Test completion")
-    return patch("mito_ai.completions.providers.AnthropicClient", return_value=mock_client)
-
-
-def test_os_user_openai_key_set_below_limit(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", FAKE_API_KEY)
-
-    with (
-        patch_server_limits(is_pro=False, completion_count=1),
-        mock_openai_client()
-    ):
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert "user key" in capabilities.provider
-        assert llm.last_error is None
-
-
-def test_os_user_openai_key_set_above_limit(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", FAKE_API_KEY)
-
-    with (
-        patch_server_limits(is_pro=False, completion_count=OS_MONTHLY_AI_COMPLETIONS_LIMIT + 1),
-        mock_openai_client()
-    ):
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert "user key" in capabilities.provider
-        assert llm.last_error is None
-
-
-def test_pro_user_openai_key_set_below_limit(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", FAKE_API_KEY)
-
-    with (
-        patch_server_limits(is_pro=True, completion_count=1),
-        mock_openai_client()
-    ):
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert "user key" in capabilities.provider
-        assert llm.last_error is None
-
-
-def test_pro_user_openai_key_set_above_limit(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", FAKE_API_KEY)
-
-    with (
-        patch_server_limits(is_pro=True, completion_count=OS_MONTHLY_AI_COMPLETIONS_LIMIT + 1),
-        mock_openai_client()
-    ):
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert "user key" in capabilities.provider
-        assert llm.last_error is None
-
-
-def test_gemini_provider(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("GEMINI_API_KEY", "gemini-key")
-    monkeypatch.setattr("mito_ai.constants.GEMINI_API_KEY", "gemini-key")
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", None)
-
-    with mock_gemini_client():
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert capabilities.provider == "Gemini"
-
-
-def test_azure_openai_provider(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setattr("mito_ai.enterprise.utils.is_enterprise", lambda: True)
-    monkeypatch.setattr("mito_ai.enterprise.utils.is_azure_openai_configured", lambda: True)
-    monkeypatch.setattr("mito_ai.enterprise.utils.AZURE_OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setattr("mito_ai.enterprise.utils.AZURE_OPENAI_ENDPOINT", "https://example.com")
-    monkeypatch.setattr("mito_ai.enterprise.utils.AZURE_OPENAI_MODEL", "gpt-4o")
-    monkeypatch.setattr("mito_ai.enterprise.utils.AZURE_OPENAI_API_VERSION", "2024-12-01-preview")
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", None)
-
-    with mock_azure_openai_client():
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert capabilities.provider == "Azure OpenAI"
-
-
-def test_claude_provider(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("CLAUDE_API_KEY", "claude-key")
-    monkeypatch.setattr("mito_ai.constants.CLAUDE_API_KEY", "claude-key")
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", None)
-
-    with mock_claude_client():
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert capabilities.provider == "Claude"
-
-
-def test_provider_priority_order(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    # Set up all possible providers
-    monkeypatch.setattr("mito_ai.enterprise.utils.is_enterprise", lambda: True)
-    monkeypatch.setattr("mito_ai.enterprise.utils.is_azure_openai_configured", lambda: True)
-    monkeypatch.setattr("mito_ai.enterprise.utils.AZURE_OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setattr("mito_ai.enterprise.utils.AZURE_OPENAI_ENDPOINT", "https://example.com")
-    monkeypatch.setattr("mito_ai.enterprise.utils.AZURE_OPENAI_MODEL", "gpt-4o")
-    monkeypatch.setattr("mito_ai.enterprise.utils.AZURE_OPENAI_API_VERSION", "2024-12-01-preview")
-    monkeypatch.setenv("OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setenv("CLAUDE_API_KEY", "claude-key")
-    monkeypatch.setattr("mito_ai.constants.CLAUDE_API_KEY", "claude-key")
-
-    # Azure OpenAI should have highest priority when enterprise is enabled
-    # Clear other provider settings to ensure Azure OpenAI is selected
-    monkeypatch.delenv("GEMINI_API_KEY", raising=False)
-    monkeypatch.setattr("mito_ai.constants.GEMINI_API_KEY", None)
-    # Clear Claude settings to ensure Azure OpenAI is selected
-    monkeypatch.delenv("CLAUDE_API_KEY", raising=False)
-    monkeypatch.setattr("mito_ai.constants.CLAUDE_API_KEY", None)
-    with mock_azure_openai_client():
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert capabilities.provider == "Azure OpenAI"
-
-    # Without enterprise, OpenAI should have highest priority
-    monkeypatch.setattr("mito_ai.enterprise.utils.is_enterprise", lambda: False)
-    monkeypatch.setattr("mito_ai.enterprise.utils.is_azure_openai_configured", lambda: False)
-    with mock_openai_client():
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert capabilities.provider == "OpenAI with user key"
-
-    # Without OpenAI key, Claude should be used (higher priority than Gemini)
-    monkeypatch.delenv("OPENAI_API_KEY")
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", None)
-    # Ensure provider_config doesn't have an api_key set
-    provider_config.OpenAIProvider.api_key = None
-    # Re-enable Claude settings
-    monkeypatch.setenv("CLAUDE_API_KEY", "claude-key")
-    monkeypatch.setattr("mito_ai.constants.CLAUDE_API_KEY", "claude-key")
-    with mock_claude_client():
-        llm = OpenAIProvider(config=provider_config)
-        capabilities = llm.capabilities
-        assert capabilities.provider == "Claude"
-
-
-@pytest.mark.asyncio
-async def test_completion_request(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", FAKE_API_KEY)
-
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "gpt-4o-mini"},
-        provider="OpenAI with user key",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "user"
-    mock_client.request_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_completions = AsyncMock(return_value="Test completion")
-
-    with patch("mito_ai.completions.providers.OpenAIClient", return_value=mock_client):
-        llm = OpenAIProvider(config=provider_config)
-        messages: List[ChatCompletionMessageParam] = [
-            {"role": "user", "content": "Test message"}
-        ]
-
-        completion = await llm.request_completions(
-            message_type=MessageType.CHAT,
-            messages=messages,
-            model="gpt-4o-mini"
-        )
-
-        assert completion == "Test completion"
-        mock_client.request_completions.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_stream_completion(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("OPENAI_API_KEY", FAKE_API_KEY)
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", FAKE_API_KEY)
-
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "gpt-4o-mini"},
-        provider="OpenAI with user key",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "user"
-    mock_client.request_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_completions = AsyncMock(return_value="Test completion")
-
-    with patch("mito_ai.completions.providers.OpenAIClient", return_value=mock_client):
-        llm = OpenAIProvider(config=provider_config)
-        messages: List[ChatCompletionMessageParam] = [
-            {"role": "user", "content": "Test message"}
-        ]
-
-        reply_chunks = []
-        def mock_reply(chunk):
-            reply_chunks.append(chunk)
-
-        completion = await llm.stream_completions(
-            message_type=MessageType.CHAT,
-            messages=messages,
-            model="gpt-4o-mini",
-            message_id="test-id",
-            thread_id="test-thread",
-            reply_fn=mock_reply
-        )
-
-        assert completion == "Test completion"
-        mock_client.stream_completions.assert_called_once()
-        assert len(reply_chunks) > 0
-        assert isinstance(reply_chunks[0], CompletionReply)
-
-
-def test_error_handling(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("OPENAI_API_KEY", "invalid-key")
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", "invalid-key")
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "gpt-4o-mini"},
-        provider="OpenAI with user key",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "user"
-    mock_client.request_completions.side_effect = Exception("API error")
-
-    with patch("mito_ai.completions.providers.OpenAIClient", return_value=mock_client):
-        llm = OpenAIProvider(config=provider_config)
-        assert llm.last_error is None  # Error should be None until a request is made
-
-
-@pytest.mark.asyncio
-async def test_claude_completion_request(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("CLAUDE_API_KEY", "claude-key")
-    monkeypatch.setattr("mito_ai.constants.CLAUDE_API_KEY", "claude-key")
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", None)
-
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "claude-3-opus-20240229"},
-        provider="Claude",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "claude"
-    mock_client.request_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_completions = AsyncMock(return_value="Test completion")
-
-    with patch("mito_ai.completions.providers.AnthropicClient", return_value=mock_client):
-        llm = OpenAIProvider(config=provider_config)
-        messages: List[ChatCompletionMessageParam] = [
-            {"role": "user", "content": "Test message"}
-        ]
-
-        completion = await llm.request_completions(
-            message_type=MessageType.CHAT,
-            messages=messages,
-            model="claude-3-opus-20240229"
-        )
-
-        assert completion == "Test completion"
-        mock_client.request_completions.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_claude_stream_completion(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("CLAUDE_API_KEY", "claude-key")
-    monkeypatch.setattr("mito_ai.constants.CLAUDE_API_KEY", "claude-key")
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", None)
-
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "claude-3-opus-20240229"},
-        provider="Claude",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "claude"
-    mock_client.request_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_completions = AsyncMock(return_value="Test completion")
-    mock_client.stream_response = AsyncMock(return_value="Test completion")
-
-    with patch("mito_ai.completions.providers.AnthropicClient", return_value=mock_client):
-        llm = OpenAIProvider(config=provider_config)
-        messages: List[ChatCompletionMessageParam] = [
-            {"role": "user", "content": "Test message"}
-        ]
-
-        reply_chunks = []
-        def mock_reply(chunk):
-            reply_chunks.append(chunk)
-
-        completion = await llm.stream_completions(
-            message_type=MessageType.CHAT,
-            messages=messages,
-            model="claude-3-opus-20240229",
-            message_id="test-id",
-            thread_id="test-thread",
-            reply_fn=mock_reply
-        )
-
-        assert completion == "Test completion"
-        mock_client.stream_response.assert_called_once()
-        assert len(reply_chunks) > 0
-        assert isinstance(reply_chunks[0], CompletionReply)
-
-
-def test_claude_error_handling(monkeypatch: pytest.MonkeyPatch, provider_config: Config) -> None:
-    monkeypatch.setenv("CLAUDE_API_KEY", "invalid-key")
-    monkeypatch.setattr("mito_ai.constants.CLAUDE_API_KEY", "invalid-key")
-    monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", None)
-
-    mock_client = MagicMock()
-    mock_client.capabilities = AICapabilities(
-        configuration={"model": "claude-3-opus-20240229"},
-        provider="Claude",
-        type="ai_capabilities"
-    )
-    mock_client.key_type = "claude"
-    mock_client.request_completions.side_effect = Exception("API error")
-
-    with patch("mito_ai.completions.providers.AnthropicClient", return_value=mock_client):
-        llm = OpenAIProvider(config=provider_config)
-        assert llm.last_error is None  # Error should be None until a request is made