mito-ai 0.1.57__py3-none-any.whl → 0.1.58__py3-none-any.whl

mito_ai/streamlit_conversion/streamlit_agent_handler.py

@@ -1,9 +1,10 @@
 # Copyright (c) Saga Inc.
 # Distributed under the terms of the GNU Affero General Public License v3.0 License.
 
-from anthropic.types import MessageParam
-from typing import List, cast
-from mito_ai.streamlit_conversion.agent_utils import extract_todo_placeholders, get_response_from_agent
+from typing import List
+from openai.types.chat import ChatCompletionMessageParam
+from mito_ai.streamlit_conversion.agent_utils import extract_todo_placeholders
+from mito_ai.provider_manager import ProviderManager
 from mito_ai.streamlit_conversion.prompts.streamlit_app_creation_prompt import get_streamlit_app_creation_prompt
 from mito_ai.streamlit_conversion.prompts.streamlit_error_correction_prompt import get_streamlit_error_correction_prompt
 from mito_ai.streamlit_conversion.prompts.streamlit_finish_todo_prompt import get_finish_todo_prompt
@@ -15,22 +16,23 @@ from mito_ai.completions.models import MessageType
 from mito_ai.utils.error_classes import StreamlitConversionError
 from mito_ai.utils.telemetry_utils import log_streamlit_app_validation_retry, log_streamlit_app_conversion_success
 from mito_ai.path_utils import AbsoluteNotebookPath, AppFileName, get_absolute_notebook_dir_path, get_absolute_app_path, get_app_file_name
+from mito_ai.streamlit_conversion.prompts.streamlit_system_prompt import streamlit_system_prompt
 
-async def generate_new_streamlit_code(notebook: List[dict], streamlit_app_prompt: str) -> str:
+async def generate_new_streamlit_code(notebook: List[dict], streamlit_app_prompt: str, provider: ProviderManager) -> str:
     """Send a query to the agent, get its response and parse the code"""
     
     prompt_text = get_streamlit_app_creation_prompt(notebook, streamlit_app_prompt)
     
-    messages: List[MessageParam] = [
-        cast(MessageParam, {
-            "role": "user",
-            "content": [{
-                "type": "text",
-                "text": prompt_text
-            }]
-        })
+    messages: List[ChatCompletionMessageParam] = [
+        {"role": "system", "content": streamlit_system_prompt},
+        {"role": "user", "content": prompt_text}
     ]
-    agent_response = await get_response_from_agent(messages)
+    agent_response = await provider.request_completions(
+        message_type=MessageType.STREAMLIT_CONVERSION,
+        messages=messages,
+        use_smartest_model=True,
+        thread_id=None
+    )
     converted_code = extract_code_blocks(agent_response)
     
     # Extract the TODOs from the agent's response
@@ -39,16 +41,16 @@ async def generate_new_streamlit_code(notebook: List[dict], streamlit_app_prompt
     for todo_placeholder in todo_placeholders:
         print(f"Processing AI TODO: {todo_placeholder}")
         todo_prompt = get_finish_todo_prompt(notebook, converted_code, todo_placeholder)
-        todo_messages: List[MessageParam] = [
-            cast(MessageParam, {
-                "role": "user",
-                "content": [{
-                    "type": "text",
-                    "text": todo_prompt
-                }]
-            })
+        todo_messages: List[ChatCompletionMessageParam] = [
+            {"role": "system", "content": streamlit_system_prompt},
+            {"role": "user", "content": todo_prompt}
         ]
-        todo_response = await get_response_from_agent(todo_messages)
+        todo_response = await provider.request_completions(
+            message_type=MessageType.STREAMLIT_CONVERSION,
+            messages=todo_messages,
+            use_smartest_model=True,
+            thread_id=None
+        )
         
         # Apply the search/replace to the streamlit app
         search_replace_pairs = extract_search_replace_blocks(todo_response)
@@ -57,21 +59,21 @@ async def generate_new_streamlit_code(notebook: List[dict], streamlit_app_prompt
     return converted_code
 
 
-async def update_existing_streamlit_code(notebook: List[dict], streamlit_app_code: str, edit_prompt: str) -> str:
+async def update_existing_streamlit_code(notebook: List[dict], streamlit_app_code: str, edit_prompt: str, provider: ProviderManager) -> str:
     """Send a query to the agent, get its response and parse the code"""
     prompt_text = get_update_existing_app_prompt(notebook, streamlit_app_code, edit_prompt)
     
-    messages: List[MessageParam] = [
-        cast(MessageParam, {
-            "role": "user",
-            "content": [{
-                "type": "text",
-                "text": prompt_text
-            }]
-        })
+    messages: List[ChatCompletionMessageParam] = [
+        {"role": "system", "content": streamlit_system_prompt},
+        {"role": "user", "content": prompt_text}
     ]
     
-    agent_response = await get_response_from_agent(messages)
+    agent_response = await provider.request_completions(
+        message_type=MessageType.STREAMLIT_CONVERSION,
+        messages=messages,
+        use_smartest_model=True,
+        thread_id=None
+    )
     print(f"[Mito AI Search/Replace Tool]:\n {agent_response}")
 
     # Apply the search/replace to the streamlit app
@@ -81,18 +83,18 @@ async def update_existing_streamlit_code(notebook: List[dict], streamlit_app_cod
     return converted_code
 
 
-async def correct_error_in_generation(error: str, streamlit_app_code: str) -> str:
+async def correct_error_in_generation(error: str, streamlit_app_code: str, provider: ProviderManager) -> str:
     """If errors are present, send it back to the agent to get corrections in code"""
-    messages: List[MessageParam] = [
-        cast(MessageParam, {
-            "role": "user",
-            "content": [{
-                "type": "text",
-                "text": get_streamlit_error_correction_prompt(error, streamlit_app_code)
-            }]
-        })
+    messages: List[ChatCompletionMessageParam] = [
+        {"role": "system", "content": streamlit_system_prompt},
+        {"role": "user", "content": get_streamlit_error_correction_prompt(error, streamlit_app_code)}
     ]
-    agent_response = await get_response_from_agent(messages)
+    agent_response = await provider.request_completions(
+        message_type=MessageType.STREAMLIT_CONVERSION,
+        messages=messages,
+        use_smartest_model=True,
+        thread_id=None
+    )
     
     # Apply the search/replace to the streamlit app
     search_replace_pairs = extract_search_replace_blocks(agent_response)
@@ -100,7 +102,7 @@ async def correct_error_in_generation(error: str, streamlit_app_code: str) -> st
 
     return streamlit_app_code
 
-async def streamlit_handler(create_new_app: bool, notebook_path: AbsoluteNotebookPath, app_file_name: AppFileName, streamlit_app_prompt: str = "") -> None:
+async def streamlit_handler(create_new_app: bool, notebook_path: AbsoluteNotebookPath, app_file_name: AppFileName, streamlit_app_prompt: str, provider: ProviderManager) -> None:
     """Handler function for streamlit code generation and validation"""
 
     # Convert to absolute path for consistent handling
@@ -110,7 +112,7 @@ async def streamlit_handler(create_new_app: bool, notebook_path: AbsoluteNoteboo
     
     if create_new_app:
         # Otherwise generate a new streamlit app
-        streamlit_code = await generate_new_streamlit_code(notebook_code, streamlit_app_prompt)
+        streamlit_code = await generate_new_streamlit_code(notebook_code, streamlit_app_prompt, provider)
     else:
         # If the user is editing an existing streamlit app, use the update function
         existing_streamlit_code = get_app_code_from_file(app_path)
@@ -118,14 +120,14 @@ async def streamlit_handler(create_new_app: bool, notebook_path: AbsoluteNoteboo
         if existing_streamlit_code is None:
             raise StreamlitConversionError("Error updating existing streamlit app because app.py file was not found.", 404)
         
-        streamlit_code = await update_existing_streamlit_code(notebook_code, existing_streamlit_code, streamlit_app_prompt) 
+        streamlit_code = await update_existing_streamlit_code(notebook_code, existing_streamlit_code, streamlit_app_prompt, provider) 
        
     # Then, after creating/updating the app, validate that the new code runs 
     errors = validate_app(streamlit_code, notebook_path)
     tries = 0
     while len(errors) > 0 and tries < 5:
         for error in errors:
-            streamlit_code = await correct_error_in_generation(error, streamlit_code)
+            streamlit_code = await correct_error_in_generation(error, streamlit_code, provider)
         
         errors = validate_app(streamlit_code, notebook_path)
         

mito_ai/streamlit_preview/handlers.py

@@ -11,15 +11,18 @@ from mito_ai.utils.telemetry_utils import log_streamlit_app_conversion_error, lo
 from mito_ai.completions.models import MessageType
 from mito_ai.utils.error_classes import StreamlitConversionError, StreamlitPreviewError
 from mito_ai.streamlit_conversion.streamlit_agent_handler import streamlit_handler
+from mito_ai.provider_manager import ProviderManager
 import traceback
 
 
 class StreamlitPreviewHandler(APIHandler):
     """REST handler for streamlit preview operations."""
 
-    def initialize(self) -> None:
+    def initialize(self, llm: ProviderManager) -> None:
         """Initialize the handler."""
+        super().initialize()
         self.preview_manager = StreamlitPreviewManager()
+        self._llm = llm
 
     @tornado.web.authenticated
     
@@ -45,11 +48,11 @@ class StreamlitPreviewHandler(APIHandler):
                     print("[Mito AI] Force recreating streamlit app")
 
                 # Create a new app 
-                await streamlit_handler(True, absolute_notebook_path, app_file_name, streamlit_app_prompt)
+                await streamlit_handler(True, absolute_notebook_path, app_file_name, streamlit_app_prompt, self._llm)
             elif streamlit_app_prompt != '':
                 # Update an existing app if there is a prompt provided. Otherwise, the user is just
                 # starting an existing app so we can skip the streamlit_handler all together
-                await streamlit_handler(False, absolute_notebook_path, app_file_name, streamlit_app_prompt)
+                await streamlit_handler(False, absolute_notebook_path, app_file_name, streamlit_app_prompt, self._llm)
 
             # Start preview
             # TODO: There's a bug here where when the user rebuilds and already running app. Instead of 

mito_ai/streamlit_preview/urls.py

@@ -4,12 +4,14 @@
 from typing import Any, List, Tuple
 from jupyter_server.utils import url_path_join
 from mito_ai.streamlit_preview.handlers import StreamlitPreviewHandler
+from mito_ai.provider_manager import ProviderManager
 
-def get_streamlit_preview_urls(base_url: str) -> List[Tuple[str, Any, dict]]:
+def get_streamlit_preview_urls(base_url: str, provider_manager: ProviderManager) -> List[Tuple[str, Any, dict]]:
     """Get all streamlit preview related URL patterns.
 
     Args:
         base_url: The base URL for the Jupyter server
+        provider_manager: The ProviderManager instance
 
     Returns:
         List of (url_pattern, handler_class, handler_kwargs) tuples
@@ -17,6 +19,6 @@ def get_streamlit_preview_urls(base_url: str) -> List[Tuple[str, Any, dict]]:
     BASE_URL = base_url + "/mito-ai"
     
     return [
-        (url_path_join(BASE_URL, "streamlit-preview"), StreamlitPreviewHandler, {}),
-        (url_path_join(BASE_URL, "streamlit-preview/(.+)"), StreamlitPreviewHandler, {}),
+        (url_path_join(BASE_URL, "streamlit-preview"), StreamlitPreviewHandler, {"llm": provider_manager}),
+        (url_path_join(BASE_URL, "streamlit-preview/(.+)"), StreamlitPreviewHandler, {"llm": provider_manager}),
     ]

mito_ai/tests/message_history/test_generate_short_chat_name.py

@@ -5,24 +5,25 @@ import pytest
 from unittest.mock import AsyncMock, MagicMock, patch
 from traitlets.config import Config
 from mito_ai.completions.message_history import generate_short_chat_name
-from mito_ai.completions.providers import OpenAIProvider
+from mito_ai.provider_manager import ProviderManager
 
 
 @pytest.fixture
 def provider_config() -> Config:
-    """Create a proper Config object for the OpenAIProvider."""
+    """Create a proper Config object for the ProviderManager."""
     config = Config()
-    config.OpenAIProvider = Config()
+    config.ProviderManager = Config()
     config.OpenAIClient = Config()
     return config
 
 
 # Test cases for different models and their expected providers/fast models
 PROVIDER_TEST_CASES = [
-    # (model, client_patch_path)
-    ("gpt-4.1", "mito_ai.completions.providers.OpenAIClient"),
-    ("claude-3-5-sonnet-20241022", "mito_ai.completions.providers.AnthropicClient"),
-    ("gemini-2.0-flash-exp", "mito_ai.completions.providers.GeminiClient")
+    # (model, client_patch_path) - patch where the classes are used (in provider_manager)
+    ("gpt-4.1", "mito_ai.provider_manager.OpenAIClient"),
+    ("claude-sonnet-4-5-20250929", "mito_ai.provider_manager.AnthropicClient"),
+    ("gemini-3-flash-preview", "mito_ai.provider_manager.GeminiClient"),
+    ("openai/gpt-4o", "mito_ai.provider_manager.LiteLLMClient"),  # LiteLLM test case
 ]
 
 @pytest.mark.parametrize("selected_model,client_patch_path", PROVIDER_TEST_CASES)
@@ -37,31 +38,77 @@ async def test_generate_short_chat_name_uses_correct_provider_and_fast_model(
     
     # Set up environment variables for all providers
     monkeypatch.setenv("OPENAI_API_KEY", "fake-openai-key")
-    monkeypatch.setenv("CLAUDE_API_KEY", "fake-claude-key")
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "fake-claude-key")
     monkeypatch.setenv("GEMINI_API_KEY", "fake-gemini-key")
     monkeypatch.setattr("mito_ai.constants.OPENAI_API_KEY", "fake-openai-key")
-    monkeypatch.setattr("mito_ai.constants.CLAUDE_API_KEY", "fake-claude-key")
+    monkeypatch.setattr("mito_ai.constants.ANTHROPIC_API_KEY", "fake-claude-key")
     monkeypatch.setattr("mito_ai.constants.GEMINI_API_KEY", "fake-gemini-key")
     
+    # Set up LiteLLM constants if testing LiteLLM
+    if "LiteLLMClient" in client_patch_path:
+        # Patch constants both at the source and where they're imported in model_utils
+        monkeypatch.setattr("mito_ai.constants.LITELLM_BASE_URL", "https://litellm-server.com")
+        monkeypatch.setattr("mito_ai.constants.LITELLM_API_KEY", "fake-litellm-key")
+        monkeypatch.setattr("mito_ai.constants.LITELLM_MODELS", ["openai/gpt-4o", "anthropic/claude-3-5-sonnet"])
+        # Also patch where constants is imported in model_utils (where get_available_models uses it)
+        monkeypatch.setattr("mito_ai.utils.model_utils.constants.LITELLM_BASE_URL", "https://litellm-server.com")
+        monkeypatch.setattr("mito_ai.utils.model_utils.constants.LITELLM_MODELS", ["openai/gpt-4o", "anthropic/claude-3-5-sonnet"])
+        # Mock is_enterprise to return True so LiteLLM models are available
+        monkeypatch.setattr("mito_ai.utils.version_utils.is_enterprise", lambda: True)
+    
     # Create mock client for the specific provider being tested
     mock_client = MagicMock()
     mock_client.request_completions = AsyncMock(return_value="Test Chat Name")
     
+    # Create the ProviderManager first
+    llm_provider = ProviderManager(config=provider_config)
+    
+    # Set the selected model (this is required for the ProviderManager to use the correct model)
+    llm_provider.set_selected_model(selected_model)
+    
     # Patch the specific client class that should be used based on the model
-    # We need to patch before creating the OpenAIProvider since OpenAI client is created in constructor
-    with patch(client_patch_path, return_value=mock_client):
-        # Create the OpenAIProvider after patching so the mock client is used
-        llm_provider = OpenAIProvider(config=provider_config)
-        
-        # Test the function
-        result = await generate_short_chat_name(
-            user_message="What is the capital of France?",
-            assistant_message="The capital of France is Paris.",
-            model=selected_model,
-            llm_provider=llm_provider
-        )
-        
-    # Verify that the correct client's request_completions was called
+    # For Anthropic, Gemini, and LiteLLM, new instances are created in request_completions, so we patch the class
+    # For OpenAI, the instance is created in __init__, so we patch the instance's method
+    if "AnthropicClient" in client_patch_path:
+        with patch(client_patch_path, return_value=mock_client):
+            result = await generate_short_chat_name(
+                user_message="What is the capital of France?",
+                assistant_message="The capital of France is Paris.",
+                llm_provider=llm_provider
+            )
+    elif "GeminiClient" in client_patch_path:
+        with patch(client_patch_path, return_value=mock_client):
+            result = await generate_short_chat_name(
+                user_message="What is the capital of France?",
+                assistant_message="The capital of France is Paris.",
+                llm_provider=llm_provider
+            )
+    elif "LiteLLMClient" in client_patch_path:
+        # Patch LiteLLMClient where it's defined (it's imported inside request_completions)
+        # Also patch get_available_models to return LiteLLM models
+        with patch("mito_ai.enterprise.litellm_client.LiteLLMClient", return_value=mock_client), \
+             patch("mito_ai.provider_manager.get_available_models", return_value=["openai/gpt-4o", "anthropic/claude-3-5-sonnet"]):
+            result = await generate_short_chat_name(
+                user_message="What is the capital of France?",
+                assistant_message="The capital of France is Paris.",
+                llm_provider=llm_provider
+            )
+    else:  # OpenAI
+        # For OpenAI, patch the instance's method since the client is created in __init__
+        assert llm_provider._openai_client is not None, "OpenAI client should be initialized"
+        with patch.object(llm_provider._openai_client, 'request_completions', new_callable=AsyncMock, return_value="Test Chat Name") as mock_openai_request:
+            result = await generate_short_chat_name(
+                user_message="What is the capital of France?",
+                assistant_message="The capital of France is Paris.",
+                llm_provider=llm_provider
+            )
+            # Verify that the OpenAI client's request_completions was called
+            mock_openai_request.assert_called_once()  # type: ignore
+            # As a double check, if we have used the correct client, then we must get the correct result
+            assert result == "Test Chat Name"
+            return
+    
+    # Verify that the correct client's request_completions was called (for Anthropic, Gemini, and LiteLLM)
     mock_client.request_completions.assert_called_once()
 
     # As a double check, if we have used the correct client, then we must get the correct result
@@ -74,13 +121,12 @@ async def test_generate_short_chat_name_cleans_gemini_response() -> None:
     """Test that generate_short_chat_name properly cleans Gemini-style responses with quotes and newlines."""
     
     # Create mock llm_provider that returns a response with quotes and newlines
-    mock_llm_provider = MagicMock(spec=OpenAIProvider)
+    mock_llm_provider = MagicMock(spec=ProviderManager)
     mock_llm_provider.request_completions = AsyncMock(return_value='"France Geography Discussion\n"')
     
     result = await generate_short_chat_name(
         user_message="What is the capital of France?",
         assistant_message="The capital of France is Paris.",
-        model="gemini-2.0-flash-exp",
         llm_provider=mock_llm_provider
     )
     
@@ -95,13 +141,12 @@ async def test_generate_short_chat_name_handles_empty_response() -> None:
     """Test that generate_short_chat_name handles empty or None responses gracefully."""
     
     # Test with empty string response
-    mock_llm_provider = MagicMock(spec=OpenAIProvider)
+    mock_llm_provider = MagicMock(spec=ProviderManager)
     mock_llm_provider.request_completions = AsyncMock(return_value="")
     
     result = await generate_short_chat_name(
         user_message="Test message",
         assistant_message="Test response",
-        model="gpt-4.1",
         llm_provider=mock_llm_provider
     )
     
@@ -113,7 +158,6 @@ async def test_generate_short_chat_name_handles_empty_response() -> None:
     result = await generate_short_chat_name(
         user_message="Test message", 
         assistant_message="Test response",
-        model="gpt-4.1",
         llm_provider=mock_llm_provider
     )
     

mito_ai/tests/providers/test_anthropic_client.py

@@ -3,11 +3,10 @@
 
 import pytest
 from mito_ai.anthropic_client import get_anthropic_system_prompt_and_messages, get_anthropic_system_prompt_and_messages_with_caching, add_cache_control_to_message, extract_and_parse_anthropic_json_response, AnthropicClient
-from mito_ai.utils.anthropic_utils import FAST_ANTHROPIC_MODEL
 from anthropic.types import Message, TextBlock, ToolUseBlock, Usage, ToolUseBlock, Message, Usage, TextBlock
 from openai.types.chat import ChatCompletionMessageParam, ChatCompletionUserMessageParam, ChatCompletionAssistantMessageParam, ChatCompletionSystemMessageParam
 from mito_ai.completions.models import MessageType
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 import anthropic
 from typing import List, Dict, cast
 
@@ -233,24 +232,25 @@ def test_tool_use_without_agent_response():
     assert "No valid AgentResponse format found" in str(exc_info.value)
 
 CUSTOM_MODEL = "smart-anthropic-model"
-@pytest.mark.parametrize("message_type, expected_model", [
-    (MessageType.CHAT, CUSTOM_MODEL),  #
-    (MessageType.SMART_DEBUG, CUSTOM_MODEL),  #
-    (MessageType.CODE_EXPLAIN, CUSTOM_MODEL),  #
-    (MessageType.AGENT_EXECUTION, CUSTOM_MODEL),  #
-    (MessageType.AGENT_AUTO_ERROR_FIXUP, CUSTOM_MODEL),  #
-    (MessageType.INLINE_COMPLETION, FAST_ANTHROPIC_MODEL),  #
-    (MessageType.CHAT_NAME_GENERATION, FAST_ANTHROPIC_MODEL),  #
+@pytest.mark.parametrize("message_type", [
+    MessageType.CHAT,
+    MessageType.SMART_DEBUG,
+    MessageType.CODE_EXPLAIN,
+    MessageType.AGENT_EXECUTION,
+    MessageType.AGENT_AUTO_ERROR_FIXUP,
+    MessageType.INLINE_COMPLETION,
+    MessageType.CHAT_NAME_GENERATION,
 ])
 @pytest.mark.asyncio 
-async def test_model_selection_based_on_message_type(message_type, expected_model):
+async def test_model_selection_uses_passed_model(message_type):
     """
-    Tests that the correct model is selected based on the message type.
+    Tests that the model passed to the client is used as-is.
+    Model selection based on message type is now handled by ProviderManager.
     """
     client = AnthropicClient(api_key="test_key")
     
-    # Mock the messages.create method directly
-    with patch.object(client.client.messages, 'create') as mock_create: # type: ignore
+    # Mock the beta.messages.create method directly (we now use beta API)
+    with patch.object(client.client.beta.messages, 'create') as mock_create: # type: ignore
         # Create a mock response
         mock_response = Message(
             id="test_id",
@@ -269,10 +269,168 @@ async def test_model_selection_based_on_message_type(message_type, expected_mode
             response_format_info=None
         )
         
-        # Verify that create was called with the expected model
+        # Verify that create was called with the model that was passed (not overridden)
         mock_create.assert_called_once()
         call_args = mock_create.call_args
-        assert call_args[1]['model'] == expected_model
+        assert call_args[1]['model'] == CUSTOM_MODEL
+
+@pytest.mark.asyncio
+async def test_anthropic_client_uses_fast_model_from_provider_manager_without_override():
+    """Test that Anthropic client uses the fast model passed from ProviderManager without internal override."""
+    from mito_ai.utils.model_utils import get_fast_model_for_selected_model
+    
+    client = AnthropicClient(api_key="test_key")
+    
+    # Mock the beta.messages.create method directly (we now use beta API)
+    with patch.object(client.client.beta.messages, 'create') as mock_create: # type: ignore
+        # Create a mock response
+        mock_response = Message(
+            id="test_id",
+            role="assistant",
+            content=[TextBlock(type="text", text="test")], 
+            model='anthropic-model-we-do-not-check', 
+            type="message",
+            usage=Usage(input_tokens=0, output_tokens=0)
+        )
+        mock_create.return_value = mock_response
+
+        # Use a fast model that would be selected by ProviderManager
+        fast_model = get_fast_model_for_selected_model("claude-sonnet-4-5-20250929")
+        
+        await client.request_completions(
+            messages=[{"role": "user", "content": "Test message"}],
+            model=fast_model,
+            message_type=MessageType.CHAT,
+            response_format_info=None
+        )
+        
+        # Verify that create was called with the fast model that was passed (not overridden)
+        mock_create.assert_called_once()
+        call_args = mock_create.call_args
+        assert call_args[1]['model'] == fast_model
+
+@pytest.mark.asyncio
+async def test_anthropic_client_uses_smartest_model_from_provider_manager_without_override():
+    """Test that Anthropic client uses the smartest model passed from ProviderManager without internal override."""
+    from mito_ai.utils.model_utils import get_smartest_model_for_selected_model
+    
+    client = AnthropicClient(api_key="test_key")
+    
+    # Mock the beta.messages.create method directly (we now use beta API)
+    with patch.object(client.client.beta.messages, 'create') as mock_create: # type: ignore
+        # Create a mock response
+        mock_response = Message(
+            id="test_id",
+            role="assistant",
+            content=[TextBlock(type="text", text="test")], 
+            model='anthropic-model-we-do-not-check', 
+            type="message",
+            usage=Usage(input_tokens=0, output_tokens=0)
+        )
+        mock_create.return_value = mock_response
+
+        # Use a smartest model that would be selected by ProviderManager
+        smartest_model = get_smartest_model_for_selected_model("claude-haiku-4-5-20251001")
+        
+        await client.request_completions(
+            messages=[{"role": "user", "content": "Test message"}],
+            model=smartest_model,
+            message_type=MessageType.CHAT,
+            response_format_info=None
+        )
+        
+        # Verify that create was called with the smartest model that was passed (not overridden)
+        mock_create.assert_called_once()
+        call_args = mock_create.call_args
+        assert call_args[1]['model'] == smartest_model
+
+@pytest.mark.asyncio
+async def test_anthropic_client_stream_uses_fast_model_from_provider_manager_without_override():
+    """Test that Anthropic client stream_completions uses the fast model passed from ProviderManager without internal override."""
+    from mito_ai.utils.model_utils import get_fast_model_for_selected_model
+    
+    client = AnthropicClient(api_key="test_key")
+    
+    # Mock the beta.messages.create method for streaming
+    with patch.object(client.client.beta.messages, 'create') as mock_create: # type: ignore
+        # Create a mock stream response
+        class MockStreamChunk:
+            def __init__(self, chunk_type, text=""):
+                self.type = chunk_type
+                if chunk_type == "content_block_delta":
+                    self.delta = MagicMock()
+                    self.delta.type = "text_delta"
+                    self.delta.text = text
+        
+        mock_stream = [
+            MockStreamChunk("content_block_delta", "test"),
+            MockStreamChunk("message_stop")
+        ]
+        mock_create.return_value = iter(mock_stream)
+
+        # Use a fast model that would be selected by ProviderManager
+        fast_model = get_fast_model_for_selected_model("claude-sonnet-4-5-20250929")
+        
+        reply_chunks = []
+        def mock_reply(chunk):
+            reply_chunks.append(chunk)
+        
+        await client.stream_completions(
+            messages=[{"role": "user", "content": "Test message"}],
+            model=fast_model,
+            message_id="test-id",
+            message_type=MessageType.CHAT,
+            reply_fn=mock_reply
+        )
+        
+        # Verify that create was called with the fast model that was passed (not overridden)
+        mock_create.assert_called_once()
+        call_args = mock_create.call_args
+        assert call_args[1]['model'] == fast_model
+
+@pytest.mark.asyncio
+async def test_anthropic_client_stream_uses_smartest_model_from_provider_manager_without_override():
+    """Test that Anthropic client stream_completions uses the smartest model passed from ProviderManager without internal override."""
+    from mito_ai.utils.model_utils import get_smartest_model_for_selected_model
+    
+    client = AnthropicClient(api_key="test_key")
+    
+    # Mock the beta.messages.create method for streaming
+    with patch.object(client.client.beta.messages, 'create') as mock_create: # type: ignore
+        # Create a mock stream response
+        class MockStreamChunk:
+            def __init__(self, chunk_type, text=""):
+                self.type = chunk_type
+                if chunk_type == "content_block_delta":
+                    self.delta = MagicMock()
+                    self.delta.type = "text_delta"
+                    self.delta.text = text
+        
+        mock_stream = [
+            MockStreamChunk("content_block_delta", "test"),
+            MockStreamChunk("message_stop")
+        ]
+        mock_create.return_value = iter(mock_stream)
+
+        # Use a smartest model that would be selected by ProviderManager
+        smartest_model = get_smartest_model_for_selected_model("claude-haiku-4-5-20251001")
+        
+        reply_chunks = []
+        def mock_reply(chunk):
+            reply_chunks.append(chunk)
+        
+        await client.stream_completions(
+            messages=[{"role": "user", "content": "Test message"}],
+            model=smartest_model,
+            message_id="test-id",
+            message_type=MessageType.CHAT,
+            reply_fn=mock_reply
+        )
+        
+        # Verify that create was called with the smartest model that was passed (not overridden)
+        mock_create.assert_called_once()
+        call_args = mock_create.call_args
+        assert call_args[1]['model'] == smartest_model
 
 
 # Caching Tests