kiln-ai 0.20.1__py3-none-any.whl → 0.22.0__py3-none-any.whl

kiln_ai/adapters/test_ollama_tools.py

@@ -1,13 +1,85 @@
 import json
+from unittest.mock import patch
 
+import pytest
+
+from kiln_ai.adapters.ml_embedding_model_list import (
+    KilnEmbeddingModel,
+    KilnEmbeddingModelProvider,
+)
+
+# Mock data for testing - using proper Pydantic model instances
+from kiln_ai.adapters.ml_model_list import KilnModel, KilnModelProvider
 from kiln_ai.adapters.ollama_tools import (
     OllamaConnection,
+    ollama_embedding_model_installed,
     ollama_model_installed,
     parse_ollama_tags,
 )
+from kiln_ai.datamodel.datamodel_enums import ModelProviderName
 
+MOCK_BUILT_IN_MODELS = [
+    KilnModel(
+        family="phi",
+        name="phi3.5",
+        friendly_name="phi3.5",
+        providers=[
+            KilnModelProvider(
+                name=ModelProviderName.ollama,
+                model_id="phi3.5",
+                ollama_model_aliases=None,
+            )
+        ],
+    ),
+    KilnModel(
+        family="gemma",
+        name="gemma2",
+        friendly_name="gemma2",
+        providers=[
+            KilnModelProvider(
+                name=ModelProviderName.ollama,
+                model_id="gemma2:2b",
+                ollama_model_aliases=None,
+            )
+        ],
+    ),
+    KilnModel(
+        family="llama",
+        name="llama3.1",
+        friendly_name="llama3.1",
+        providers=[
+            KilnModelProvider(
+                name=ModelProviderName.ollama,
+                model_id="llama3.1",
+                ollama_model_aliases=None,
+            )
+        ],
+    ),
+]
 
-def test_parse_ollama_tags_no_models():
+MOCK_BUILT_IN_EMBEDDING_MODELS = [
+    KilnEmbeddingModel(
+        family="gemma",
+        name="embeddinggemma",
+        friendly_name="embeddinggemma",
+        providers=[
+            KilnEmbeddingModelProvider(
+                name=ModelProviderName.ollama,
+                model_id="embeddinggemma:300m",
+                n_dimensions=768,
+                ollama_model_aliases=["embeddinggemma"],
+            )
+        ],
+    ),
+]
+
+
+@patch("kiln_ai.adapters.ollama_tools.built_in_models", MOCK_BUILT_IN_MODELS)
+@patch(
+    "kiln_ai.adapters.ollama_tools.built_in_embedding_models",
+    MOCK_BUILT_IN_EMBEDDING_MODELS,
+)
+def test_parse_ollama_tags_models():
     json_response = '{"models":[{"name":"scosman_net","model":"scosman_net:latest"},{"name":"phi3.5:latest","model":"phi3.5:latest","modified_at":"2024-10-02T12:04:35.191519822-04:00","size":2176178843,"digest":"61819fb370a3c1a9be6694869331e5f85f867a079e9271d66cb223acb81d04ba","details":{"parent_model":"","format":"gguf","family":"phi3","families":["phi3"],"parameter_size":"3.8B","quantization_level":"Q4_0"}},{"name":"gemma2:2b","model":"gemma2:2b","modified_at":"2024-09-09T16:46:38.64348929-04:00","size":1629518495,"digest":"8ccf136fdd5298f3ffe2d69862750ea7fb56555fa4d5b18c04e3fa4d82ee09d7","details":{"parent_model":"","format":"gguf","family":"gemma2","families":["gemma2"],"parameter_size":"2.6B","quantization_level":"Q4_0"}},{"name":"llama3.1:latest","model":"llama3.1:latest","modified_at":"2024-09-01T17:19:43.481523695-04:00","size":4661230720,"digest":"f66fc8dc39ea206e03ff6764fcc696b1b4dfb693f0b6ef751731dd4e6269046e","details":{"parent_model":"","format":"gguf","family":"llama","families":["llama"],"parameter_size":"8.0B","quantization_level":"Q4_0"}}]}'
     tags = json.loads(json_response)
     conn = parse_ollama_tags(tags)
@@ -16,7 +88,52 @@ def test_parse_ollama_tags_no_models():
     assert "llama3.1:latest" in conn.supported_models
     assert "scosman_net:latest" in conn.untested_models
 
+    # there should be no embedding models because the tags response does not include any embedding models
+    # that are in the built-in embedding models list
+    assert len(conn.supported_embedding_models) == 0
 
+
+@patch("kiln_ai.adapters.ollama_tools.built_in_models", MOCK_BUILT_IN_MODELS)
+@patch(
+    "kiln_ai.adapters.ollama_tools.built_in_embedding_models",
+    MOCK_BUILT_IN_EMBEDDING_MODELS,
+)
+@pytest.mark.parametrize("json_response", ["{}", '{"models": []}'])
+def test_parse_ollama_tags_no_models(json_response):
+    tags = json.loads(json_response)
+    conn = parse_ollama_tags(tags)
+    assert (
+        conn.message
+        == "Ollama is running, but no supported models are installed. Install one or more supported model, like 'ollama pull phi3.5'."
+    )
+    assert len(conn.supported_models) == 0
+    assert len(conn.untested_models) == 0
+    assert len(conn.supported_embedding_models) == 0
+
+
+@patch("kiln_ai.adapters.ollama_tools.built_in_models", MOCK_BUILT_IN_MODELS)
+@patch(
+    "kiln_ai.adapters.ollama_tools.built_in_embedding_models",
+    MOCK_BUILT_IN_EMBEDDING_MODELS,
+)
+def test_parse_ollama_tags_empty_models():
+    """Test parsing Ollama tags response with empty models list"""
+    json_response = '{"models": []}'
+    tags = json.loads(json_response)
+    conn = parse_ollama_tags(tags)
+
+    # Check that connection indicates no supported models
+    assert conn.supported_models == []
+    assert conn.untested_models == []
+    assert conn.supported_embedding_models == []
+    assert "no supported models are installed" in conn.message
+
+
+@patch("kiln_ai.adapters.ollama_tools.built_in_models", MOCK_BUILT_IN_MODELS)
+@patch(
+    "kiln_ai.adapters.ollama_tools.built_in_embedding_models",
+    MOCK_BUILT_IN_EMBEDDING_MODELS,
+)
 def test_parse_ollama_tags_only_untested_models():
     json_response = '{"models":[{"name":"scosman_net","model":"scosman_net:latest"}]}'
     tags = json.loads(json_response)
@@ -24,12 +141,17 @@ def test_parse_ollama_tags_only_untested_models():
     assert conn.supported_models == []
     assert conn.untested_models == ["scosman_net:latest"]
 
+    # there should be no embedding models because the tags response does not include any embedding models
+    # that are in the built-in embedding models list
+    assert len(conn.supported_embedding_models) == 0
+
 
 def test_ollama_model_installed():
     conn = OllamaConnection(
         supported_models=["phi3.5:latest", "gemma2:2b", "llama3.1:latest"],
         message="Connected",
         untested_models=["scosman_net:latest"],
+        supported_embedding_models=["embeddinggemma:300m"],
     )
     assert ollama_model_installed(conn, "phi3.5:latest")
     assert ollama_model_installed(conn, "phi3.5")
@@ -39,3 +161,220 @@ def test_ollama_model_installed():
     assert ollama_model_installed(conn, "scosman_net:latest")
     assert ollama_model_installed(conn, "scosman_net")
     assert not ollama_model_installed(conn, "unknown_model")
+
+    # use the ollama_embedding_model_installed for testing embedding models installed, not ollama_model_installed
+    assert not ollama_model_installed(conn, "embeddinggemma:300m")
+    assert not ollama_model_installed(conn, "embeddinggemma")
+
+
+def test_ollama_model_installed_embedding_models():
+    conn = OllamaConnection(
+        message="Connected",
+        supported_models=["phi3.5:latest", "gemma2:2b", "llama3.1:latest"],
+        untested_models=["scosman_net:latest"],
+        supported_embedding_models=["embeddinggemma:300m", "embeddinggemma:latest"],
+    )
+
+    assert ollama_embedding_model_installed(conn, "embeddinggemma:300m")
+    assert ollama_embedding_model_installed(conn, "embeddinggemma:latest")
+    assert not ollama_embedding_model_installed(conn, "unknown_embedding")
+
+    # use the ollama_model_installed for testing regular models installed, not ollama_embedding_model_installed
+    assert not ollama_embedding_model_installed(conn, "phi3.5:latest")
+    assert not ollama_embedding_model_installed(conn, "gemma2:2b")
+    assert not ollama_embedding_model_installed(conn, "llama3.1:latest")
+    assert not ollama_embedding_model_installed(conn, "scosman_net:latest")
+
+
+@patch("kiln_ai.adapters.ollama_tools.built_in_models", MOCK_BUILT_IN_MODELS)
+@patch(
+    "kiln_ai.adapters.ollama_tools.built_in_embedding_models",
+    MOCK_BUILT_IN_EMBEDDING_MODELS,
+)
+def test_parse_ollama_tags_with_embedding_models():
+    """Test parsing Ollama tags response that includes embedding models"""
+    json_response = """{
+        "models": [
+            {
+                "name": "phi3.5:latest",
+                "model": "phi3.5:latest"
+            },
+            {
+                "name": "embeddinggemma:300m",
+                "model": "embeddinggemma:300m"
+            },
+            {
+                "name": "embeddinggemma:latest",
+                "model": "embeddinggemma:latest"
+            },
+            {
+                "name": "unknown_embedding:latest",
+                "model": "unknown_embedding:latest"
+            }
+        ]
+    }"""
+    tags = json.loads(json_response)
+    conn = parse_ollama_tags(tags)
+
+    # Check that embedding models are properly categorized
+    assert "embeddinggemma:300m" in conn.supported_embedding_models
+    assert "embeddinggemma:latest" in conn.supported_embedding_models
+
+    # Check that regular models are still parsed correctly
+    assert "phi3.5:latest" in conn.supported_models
+
+    # Check that embedding models are NOT in the main model lists
+    assert "embeddinggemma:300m" not in conn.supported_models
+    assert "embeddinggemma:latest" not in conn.supported_models
+    assert "embeddinggemma:300m" not in conn.untested_models
+    assert "embeddinggemma:latest" not in conn.untested_models
+
+    # we assume the unknown models are normal models, not embedding models - because
+    # we don't support untested embedding models currently
+    assert "unknown_embedding:latest" not in conn.supported_embedding_models
+    assert "unknown_embedding:latest" in conn.untested_models
+
+
+@patch("kiln_ai.adapters.ollama_tools.built_in_models", MOCK_BUILT_IN_MODELS)
+@patch(
+    "kiln_ai.adapters.ollama_tools.built_in_embedding_models",
+    MOCK_BUILT_IN_EMBEDDING_MODELS,
+)
+def test_parse_ollama_tags_embedding_model_aliases():
+    """Test parsing Ollama tags response with embedding model aliases"""
+    json_response = """{
+        "models": [
+            {
+                "name": "embeddinggemma",
+                "model": "embeddinggemma"
+            }
+        ]
+    }"""
+    tags = json.loads(json_response)
+    conn = parse_ollama_tags(tags)
+
+    # Check that embedding model aliases are recognized
+    assert "embeddinggemma" in conn.supported_embedding_models
+
+    # Check that embedding model aliases are NOT in the main model lists
+    assert "embeddinggemma" not in conn.supported_models
+    assert "embeddinggemma" not in conn.untested_models
+
+    assert len(conn.supported_models) == 0
+    assert len(conn.untested_models) == 0
+    assert len(conn.supported_embedding_models) == 1
+
+
+@patch("kiln_ai.adapters.ollama_tools.built_in_models", MOCK_BUILT_IN_MODELS)
+@patch(
+    "kiln_ai.adapters.ollama_tools.built_in_embedding_models",
+    MOCK_BUILT_IN_EMBEDDING_MODELS,
+)
+def test_parse_ollama_tags_only_embedding_models():
+    """Test parsing Ollama tags response with only embedding models"""
+    json_response = """{
+        "models": [
+            {
+                "name": "embeddinggemma:300m",
+                "model": "embeddinggemma:300m"
+            }
+        ]
+    }"""
+    tags = json.loads(json_response)
+    conn = parse_ollama_tags(tags)
+
+    # Check that embedding models are found but no regular models
+    assert "embeddinggemma:300m" in conn.supported_embedding_models
+    assert conn.supported_models == []
+    assert conn.untested_models == []
+
+    # Check that embedding models are NOT in the main model lists
+    assert "embeddinggemma:300m" not in conn.supported_models
+    assert "embeddinggemma:300m" not in conn.untested_models
+
+
+def test_ollama_connection_all_embedding_models():
+    """Test OllamaConnection.all_embedding_models() method"""
+    conn = OllamaConnection(
+        message="Connected",
+        supported_models=["phi3.5:latest"],
+        untested_models=["unknown:latest"],
+        supported_embedding_models=["embeddinggemma:300m", "embeddinggemma:latest"],
+    )
+
+    embedding_models = conn.all_embedding_models()
+    assert embedding_models == ["embeddinggemma:300m", "embeddinggemma:latest"]
+
+
+def test_ollama_connection_empty_embedding_models():
+    """Test OllamaConnection.all_embedding_models() with empty list"""
+    conn = OllamaConnection(
+        message="Connected",
+        supported_models=["phi3.5:latest"],
+        untested_models=["unknown:latest"],
+        supported_embedding_models=[],
+    )
+
+    embedding_models = conn.all_embedding_models()
+    assert embedding_models == []
+
+
+@patch("kiln_ai.adapters.ollama_tools.built_in_models", MOCK_BUILT_IN_MODELS)
+@patch(
+    "kiln_ai.adapters.ollama_tools.built_in_embedding_models",
+    MOCK_BUILT_IN_EMBEDDING_MODELS,
+)
+def test_parse_ollama_tags_mixed_models_and_embeddings():
+    """Test parsing response with mix of regular models, embedding models, and unknown models"""
+    json_response = """{
+        "models": [
+            {
+                "name": "phi3.5:latest",
+                "model": "phi3.5:latest"
+            },
+            {
+                "name": "gemma2:2b",
+                "model": "gemma2:2b"
+            },
+            {
+                "name": "embeddinggemma:300m",
+                "model": "embeddinggemma:300m"
+            },
+            {
+                "name": "embeddinggemma",
+                "model": "embeddinggemma"
+            },
+            {
+                "name": "unknown_model:latest",
+                "model": "unknown_model:latest"
+            },
+            {
+                "name": "unknown_embedding:latest",
+                "model": "unknown_embedding:latest"
+            }
+        ]
+    }"""
+    tags = json.loads(json_response)
+    conn = parse_ollama_tags(tags)
+
+    # Check regular models
+    assert "phi3.5:latest" in conn.supported_models
+    assert "gemma2:2b" in conn.supported_models
+    assert "unknown_model:latest" in conn.untested_models
+
+    # Check embedding models
+    assert "embeddinggemma:300m" in conn.supported_embedding_models
+    assert "embeddinggemma" in conn.supported_embedding_models
+
+    # Check that embedding models are NOT in the main model lists
+    assert "embeddinggemma:300m" not in conn.supported_models
+    assert "embeddinggemma" not in conn.supported_models
+    assert "embeddinggemma:300m" not in conn.untested_models
+    assert "embeddinggemma" not in conn.untested_models
+
+    # Unknown embedding models should not appear in supported_embedding_models
+    assert "unknown_embedding:latest" not in conn.supported_embedding_models
+
+    # Unknown embedding models should appear in untested_models (since they're not recognized as embeddings)
+    assert "unknown_embedding:latest" not in conn.supported_models
+    assert "unknown_embedding:latest" in conn.untested_models

kiln_ai/adapters/test_prompt_builders.py

@@ -359,7 +359,7 @@ def test_prompt_builder_from_id(task_with_examples):
 
     with pytest.raises(
         ValueError,
-        match="Invalid fine-tune ID format. Expected 'project_id::task_id::fine_tune_id'",
+        match=r"Invalid fine-tune ID format. Expected 'project_id::task_id::fine_tune_id'",
     ):
         prompt_builder_from_id("fine_tune_prompt::123", task)
 

kiln_ai/adapters/test_provider_tools.py

@@ -2,6 +2,7 @@ from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
 
+from kiln_ai.adapters.adapter_registry import litellm_core_provider_config
 from kiln_ai.adapters.docker_model_runner_tools import DockerModelRunnerConnection
 from kiln_ai.adapters.ml_model_list import (
     KilnModel,
@@ -11,6 +12,7 @@ from kiln_ai.adapters.ml_model_list import (
 )
 from kiln_ai.adapters.ollama_tools import OllamaConnection
 from kiln_ai.adapters.provider_tools import (
+    LiteLlmCoreConfig,
     builtin_model_from,
     check_provider_warnings,
     core_provider,
@@ -19,7 +21,7 @@ from kiln_ai.adapters.provider_tools import (
     finetune_provider_model,
     get_model_and_provider,
     kiln_model_provider_from,
-    lite_llm_config_for_openai_compatible,
+    lite_llm_core_config_for_provider,
     lite_llm_provider_model,
     parse_custom_model_id,
     provider_enabled,
@@ -604,7 +606,7 @@ def test_openai_compatible_provider_config(mock_shared_config):
     """Test successful creation of an OpenAI compatible provider"""
     model_id = "test_provider::gpt-4"
 
-    config = lite_llm_config_for_openai_compatible(
+    config = litellm_core_provider_config(
         RunConfigProperties(
             model_name=model_id,
             model_provider_name=ModelProviderName.openai_compatible,
@@ -639,10 +641,10 @@ def test_lite_llm_config_no_api_key(mock_shared_config):
     """Test provider creation without API key (should work as some providers don't require it, but should pass NA to LiteLLM as it requires one)"""
     model_id = "no_key_provider::gpt-4"
 
-    config = lite_llm_config_for_openai_compatible(
+    config = litellm_core_provider_config(
         RunConfigProperties(
             model_name=model_id,
-            model_provider_name=ModelProviderName.openai,
+            model_provider_name=ModelProviderName.openai_compatible,
             prompt_id="simple_prompt_builder",
             structured_output_mode="json_schema",
         )
@@ -660,7 +662,7 @@ def test_lite_llm_config_no_api_key(mock_shared_config):
 def test_lite_llm_config_invalid_id():
     """Test handling of invalid model ID format"""
     with pytest.raises(ValueError) as exc_info:
-        lite_llm_config_for_openai_compatible(
+        litellm_core_provider_config(
             RunConfigProperties(
                 model_name="invalid-id-format",
                 model_provider_name=ModelProviderName.openai_compatible,
@@ -678,7 +680,7 @@ def test_lite_llm_config_no_providers(mock_shared_config):
     mock_shared_config.return_value.openai_compatible_providers = None
 
     with pytest.raises(ValueError) as exc_info:
-        lite_llm_config_for_openai_compatible(
+        litellm_core_provider_config(
             RunConfigProperties(
                 model_name="test_provider::gpt-4",
                 model_provider_name=ModelProviderName.openai_compatible,
@@ -692,7 +694,7 @@ def test_lite_llm_config_no_providers(mock_shared_config):
 def test_lite_llm_config_provider_not_found(mock_shared_config):
     """Test handling of non-existent provider"""
     with pytest.raises(ValueError) as exc_info:
-        lite_llm_config_for_openai_compatible(
+        litellm_core_provider_config(
             RunConfigProperties(
                 model_name="unknown_provider::gpt-4",
                 model_provider_name=ModelProviderName.openai_compatible,
@@ -715,7 +717,7 @@ def test_lite_llm_config_no_base_url(mock_shared_config):
     ]
 
     with pytest.raises(ValueError) as exc_info:
-        lite_llm_config_for_openai_compatible(
+        litellm_core_provider_config(
             RunConfigProperties(
                 model_name="test_provider::gpt-4",
                 model_provider_name=ModelProviderName.openai_compatible,
@@ -934,6 +936,195 @@ def test_finetune_provider_model_vertex_ai(mock_project, mock_task, mock_finetun
     assert provider.structured_output_mode == StructuredOutputMode.json_mode
 
 
+@pytest.fixture
+def mock_config_for_lite_llm_core_config():
+    with patch("kiln_ai.adapters.provider_tools.Config") as mock:
+        config_instance = Mock()
+        mock.shared.return_value = config_instance
+
+        # Set up all the config values
+        config_instance.open_router_api_key = "test-openrouter-key"
+        config_instance.open_ai_api_key = "test-openai-key"
+        config_instance.groq_api_key = "test-groq-key"
+        config_instance.bedrock_access_key = "test-aws-access-key"
+        config_instance.bedrock_secret_key = "test-aws-secret-key"
+        config_instance.ollama_base_url = "http://test-ollama:11434"
+        config_instance.fireworks_api_key = "test-fireworks-key"
+        config_instance.anthropic_api_key = "test-anthropic-key"
+        config_instance.gemini_api_key = "test-gemini-key"
+        config_instance.vertex_project_id = "test-vertex-project"
+        config_instance.vertex_location = "us-central1"
+        config_instance.together_api_key = "test-together-key"
+        config_instance.azure_openai_api_key = "test-azure-key"
+        config_instance.azure_openai_endpoint = "https://test.openai.azure.com"
+        config_instance.huggingface_api_key = "test-hf-key"
+
+        yield mock
+
+
+@pytest.mark.parametrize(
+    "provider_name,expected_config",
+    [
+        (
+            ModelProviderName.openrouter,
+            LiteLlmCoreConfig(
+                base_url="https://openrouter.ai/api/v1",
+                additional_body_options={
+                    "api_key": "test-openrouter-key",
+                },
+                default_headers={
+                    "HTTP-Referer": "https://kiln.tech/openrouter",
+                    "X-Title": "KilnAI",
+                },
+            ),
+        ),
+        (
+            ModelProviderName.openai,
+            LiteLlmCoreConfig(additional_body_options={"api_key": "test-openai-key"}),
+        ),
+        (
+            ModelProviderName.groq,
+            LiteLlmCoreConfig(additional_body_options={"api_key": "test-groq-key"}),
+        ),
+        (
+            ModelProviderName.amazon_bedrock,
+            LiteLlmCoreConfig(
+                additional_body_options={
+                    "aws_access_key_id": "test-aws-access-key",
+                    "aws_secret_access_key": "test-aws-secret-key",
+                    "aws_region_name": "us-west-2",
+                },
+            ),
+        ),
+        (
+            ModelProviderName.ollama,
+            LiteLlmCoreConfig(
+                base_url="http://test-ollama:11434/v1",
+                additional_body_options={"api_key": "NA"},
+            ),
+        ),
+        (
+            ModelProviderName.fireworks_ai,
+            LiteLlmCoreConfig(
+                additional_body_options={"api_key": "test-fireworks-key"}
+            ),
+        ),
+        (
+            ModelProviderName.anthropic,
+            LiteLlmCoreConfig(
+                additional_body_options={"api_key": "test-anthropic-key"}
+            ),
+        ),
+        (
+            ModelProviderName.gemini_api,
+            LiteLlmCoreConfig(additional_body_options={"api_key": "test-gemini-key"}),
+        ),
+        (
+            ModelProviderName.vertex,
+            LiteLlmCoreConfig(
+                additional_body_options={
+                    "vertex_project": "test-vertex-project",
+                    "vertex_location": "us-central1",
+                },
+            ),
+        ),
+        (
+            ModelProviderName.together_ai,
+            LiteLlmCoreConfig(additional_body_options={"api_key": "test-together-key"}),
+        ),
+        (
+            ModelProviderName.azure_openai,
+            LiteLlmCoreConfig(
+                base_url="https://test.openai.azure.com",
+                additional_body_options={
+                    "api_key": "test-azure-key",
+                    "api_version": "2025-02-01-preview",
+                },
+            ),
+        ),
+        (
+            ModelProviderName.huggingface,
+            LiteLlmCoreConfig(additional_body_options={"api_key": "test-hf-key"}),
+        ),
+        (ModelProviderName.kiln_fine_tune, None),
+        (ModelProviderName.kiln_custom_registry, None),
+    ],
+)
+def test_lite_llm_core_config_for_provider(
+    mock_config_for_lite_llm_core_config, provider_name, expected_config
+):
+    config = lite_llm_core_config_for_provider(provider_name)
+    assert config == expected_config
+
+
+def test_lite_llm_core_config_for_provider_openai_compatible(
+    mock_shared_config,
+):
+    config = lite_llm_core_config_for_provider(
+        ModelProviderName.openai_compatible, "no_key_provider"
+    )
+    assert config is not None
+    assert config.base_url == "https://api.nokey.com"
+    assert config.additional_body_options == {"api_key": "NA"}
+
+
+def test_lite_llm_core_config_for_provider_openai_compatible_with_openai_compatible_provider_name(
+    mock_shared_config,
+):
+    with pytest.raises(
+        ValueError, match="OpenAI compatible provider requires a provider name"
+    ):
+        lite_llm_core_config_for_provider(ModelProviderName.openai_compatible)
+
+
+def test_lite_llm_core_config_incorrect_openai_compatible_provider_name(
+    mock_shared_config,
+):
+    with pytest.raises(
+        ValueError,
+        match="OpenAI compatible provider provider_that_does_not_exist_in_compatible_openai_providers not found",
+    ):
+        lite_llm_core_config_for_provider(
+            ModelProviderName.openai_compatible,
+            "provider_that_does_not_exist_in_compatible_openai_providers",
+        )
+
+
+def test_lite_llm_core_config_for_provider_with_string(
+    mock_config_for_lite_llm_core_config,
+):
+    # test with a string instead of an enum
+    config = lite_llm_core_config_for_provider("openai")
+    assert config == LiteLlmCoreConfig(
+        additional_body_options={"api_key": "test-openai-key"}
+    )
+
+
+def test_lite_llm_core_config_for_provider_unknown_provider():
+    with pytest.raises(ValueError, match="Unhandled enum value: unknown_provider"):
+        lite_llm_core_config_for_provider("unknown_provider")
+
+
+@patch.dict("os.environ", {"OPENROUTER_BASE_URL": "https://custom-openrouter.com"})
+def test_lite_llm_core_config_for_provider_openrouter_custom_url(
+    mock_config_for_lite_llm_core_config,
+):
+    config = lite_llm_core_config_for_provider(ModelProviderName.openrouter)
+    assert config is not None
+    assert config.base_url == "https://custom-openrouter.com"
+
+
+def test_lite_llm_core_config_for_provider_ollama_default_url(
+    mock_config_for_lite_llm_core_config,
+):
+    # Override the mock to return None for ollama_base_url
+    mock_config_for_lite_llm_core_config.shared.return_value.ollama_base_url = None
+
+    config = lite_llm_core_config_for_provider(ModelProviderName.ollama)
+    assert config is not None
+    assert config.base_url == "http://localhost:11434/v1"
+
+
 @pytest.mark.asyncio
 async def test_provider_enabled_docker_model_runner_success():
     """Test provider_enabled for Docker Model Runner with successful connection"""