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

kiln_ai/adapters/model_adapters/test_saving_adapter_results.py

@@ -13,7 +13,7 @@ from kiln_ai.datamodel import (
     Task,
     Usage,
 )
-from kiln_ai.datamodel.task import RunConfig
+from kiln_ai.datamodel.task import RunConfigProperties
 from kiln_ai.utils.config import Config
 
 
@@ -41,8 +41,8 @@ def test_task(tmp_path):
 @pytest.fixture
 def adapter(test_task):
     return MockAdapter(
-        run_config=RunConfig(
-            task=test_task,
+        task=test_task,
+        run_config=RunConfigProperties(
             model_name="phi_3_5",
             model_provider_name="ollama",
             prompt_id="simple_chain_of_thought_prompt_builder",
@@ -240,8 +240,8 @@ async def test_autosave_true(test_task, adapter):
 def test_properties_for_task_output_custom_values(test_task):
     """Test that _properties_for_task_output includes custom temperature, top_p, and structured_output_mode"""
     adapter = MockAdapter(
-        run_config=RunConfig(
-            task=test_task,
+        task=test_task,
+        run_config=RunConfigProperties(
             model_name="gpt-4",
             model_provider_name="openai",
             prompt_id="simple_prompt_builder",

kiln_ai/adapters/model_adapters/test_structured_output.py

@@ -1,23 +1,19 @@
 import json
 from pathlib import Path
 from typing import Dict
+from unittest.mock import Mock, patch
 
 import pytest
+from litellm.types.utils import ModelResponse
 
 import kiln_ai.datamodel as datamodel
 from kiln_ai.adapters.adapter_registry import adapter_for_task
-from kiln_ai.adapters.ml_model_list import (
-    built_in_models,
-)
-from kiln_ai.adapters.model_adapters.base_adapter import (
-    BaseAdapter,
-    RunOutput,
-    Usage,
-)
+from kiln_ai.adapters.ml_model_list import built_in_models
+from kiln_ai.adapters.model_adapters.base_adapter import BaseAdapter, RunOutput, Usage
 from kiln_ai.adapters.ollama_tools import ollama_online
 from kiln_ai.adapters.test_prompt_adaptors import get_all_models_and_providers
 from kiln_ai.datamodel import PromptId
-from kiln_ai.datamodel.task import RunConfig, RunConfigProperties
+from kiln_ai.datamodel.task import RunConfigProperties
 from kiln_ai.datamodel.test_json_schema import json_joke_schema, json_triangle_schema
 
 
@@ -46,8 +42,8 @@ async def test_structured_output_ollama(tmp_path, model_name):
 class MockAdapter(BaseAdapter):
     def __init__(self, kiln_task: datamodel.Task, response: Dict | str | None):
         super().__init__(
-            run_config=RunConfig(
-                task=kiln_task,
+            task=kiln_task,
+            run_config=RunConfigProperties(
                 model_name="phi_3_5",
                 model_provider_name="ollama",
                 prompt_id="simple_chain_of_thought_prompt_builder",
@@ -180,8 +176,14 @@ async def run_structured_output_test(tmp_path: Path, model_name: str, provider:
     # Check reasoning models
     assert a._model_provider is not None
     if a._model_provider.reasoning_capable:
-        assert "reasoning" in run.intermediate_outputs
-        assert isinstance(run.intermediate_outputs["reasoning"], str)
+        # some providers have reasoning_capable models that do not return the reasoning
+        # for structured output responses (they provide it only for non-structured output)
+        if a._model_provider.reasoning_optional_for_structured_output:
+            # models may be updated to include the reasoning in the future
+            assert "reasoning" not in run.intermediate_outputs
+        else:
+            assert "reasoning" in run.intermediate_outputs
+            assert isinstance(run.intermediate_outputs["reasoning"], str)
 
 
 def build_structured_input_test_task(tmp_path: Path):
@@ -259,6 +261,7 @@ async def run_structured_input_task(
     model_name: str,
     provider: str,
     prompt_id: PromptId,
+    verify_trace_cot: bool = False,
 ):
     response, a, run = await run_structured_input_task_no_validation(
         task, model_name, provider, prompt_id
@@ -282,6 +285,32 @@ async def run_structured_input_task(
         assert "reasoning" in run.intermediate_outputs
         assert isinstance(run.intermediate_outputs["reasoning"], str)
 
+    # Check the trace
+    trace = run.trace
+    assert trace is not None
+    if verify_trace_cot:
+        assert len(trace) == 5
+        assert trace[0]["role"] == "system"
+        assert "You are an assistant which classifies a triangle" in trace[0]["content"]
+        assert trace[1]["role"] == "user"
+        assert trace[2]["role"] == "assistant"
+        assert trace[2].get("tool_calls") is None
+        assert trace[3]["role"] == "user"
+        assert trace[4]["role"] == "assistant"
+        assert trace[4].get("tool_calls") is None
+    else:
+        assert len(trace) == 3
+        assert trace[0]["role"] == "system"
+        assert "You are an assistant which classifies a triangle" in trace[0]["content"]
+        assert trace[1]["role"] == "user"
+        json_content = json.loads(trace[1]["content"])
+        assert json_content["a"] == 2
+        assert json_content["b"] == 2
+        assert json_content["c"] == 2
+        assert trace[2]["role"] == "assistant"
+        assert trace[2].get("tool_calls") is None
+        assert "[[equilateral]]" in trace[2]["content"]
+
 
 @pytest.mark.paid
 async def test_structured_input_gpt_4o_mini(tmp_path):
@@ -299,14 +328,91 @@ async def test_all_built_in_models_structured_input(
     )
 
 
+async def test_all_built_in_models_structured_input_mocked(tmp_path):
+    mock_response = ModelResponse(
+        model="gpt-4o-mini",
+        choices=[
+            {
+                "message": {
+                    "content": "The answer is [[equilateral]]",
+                }
+            }
+        ],
+    )
+
+    # Mock the Config.shared() method to return a mock config with required attributes
+    mock_config = Mock()
+    mock_config.open_ai_api_key = "mock_api_key"
+    mock_config.user_id = "test_user"
+
+    with (
+        patch(
+            "litellm.acompletion",
+            side_effect=[mock_response],
+        ),
+        patch("kiln_ai.utils.config.Config.shared", return_value=mock_config),
+    ):
+        await run_structured_input_test(
+            tmp_path, "llama_3_1_8b", "groq", "simple_prompt_builder"
+        )
+
+
 @pytest.mark.paid
 @pytest.mark.ollama
 @pytest.mark.parametrize("model_name,provider_name", get_all_models_and_providers())
 async def test_structured_input_cot_prompt_builder(tmp_path, model_name, provider_name):
     task = build_structured_input_test_task(tmp_path)
     await run_structured_input_task(
-        task, model_name, provider_name, "simple_chain_of_thought_prompt_builder"
+        task,
+        model_name,
+        provider_name,
+        "simple_chain_of_thought_prompt_builder",
+        verify_trace_cot=True,
+    )
+
+
+async def test_structured_input_cot_prompt_builder_mocked(tmp_path):
+    task = build_structured_input_test_task(tmp_path)
+    mock_response_1 = ModelResponse(
+        model="gpt-4o-mini",
+        choices=[
+            {
+                "message": {
+                    "content": "I'm thinking real hard... oh!",
+                }
+            }
+        ],
     )
+    mock_response_2 = ModelResponse(
+        model="gpt-4o-mini",
+        choices=[
+            {
+                "message": {
+                    "content": "After thinking, I've decided the answer is [[equilateral]]",
+                }
+            }
+        ],
+    )
+
+    # Mock the Config.shared() method to return a mock config with required attributes
+    mock_config = Mock()
+    mock_config.open_ai_api_key = "mock_api_key"
+    mock_config.user_id = "test_user"
+
+    with (
+        patch(
+            "litellm.acompletion",
+            side_effect=[mock_response_1, mock_response_2],
+        ),
+        patch("kiln_ai.utils.config.Config.shared", return_value=mock_config),
+    ):
+        await run_structured_input_task(
+            task,
+            "llama_3_1_8b",
+            "groq",
+            "simple_chain_of_thought_prompt_builder",
+            verify_trace_cot=True,
+        )
 
 
 @pytest.mark.paid

kiln_ai/adapters/parsers/__init__.py

@@ -7,4 +7,4 @@ Parsing utilities for JSON and models with custom output formats (R1, etc.)
 
 from . import base_parser, json_parser, r1_parser
 
-__all__ = ["r1_parser", "base_parser", "json_parser"]
+__all__ = ["base_parser", "json_parser", "r1_parser"]

kiln_ai/adapters/parsers/test_r1_parser.py

@@ -46,7 +46,7 @@ def test_response_with_whitespace(parser):
     assert parsed.output.strip() == "This is the result"
 
 
-def test_empty_thinking_content(parser):
+def test_empty_thinking_content_multiline(parser):
     response = RunOutput(
         output="""
         <think>

kiln_ai/adapters/provider_tools.py

@@ -2,27 +2,25 @@ import logging
 from dataclasses import dataclass
 from typing import Dict, List
 
+from kiln_ai.adapters.docker_model_runner_tools import (
+    get_docker_model_runner_connection,
+)
 from kiln_ai.adapters.ml_model_list import (
     KilnModel,
     KilnModelProvider,
-    ModelName,
     ModelParserID,
     ModelProviderName,
     StructuredOutputMode,
     built_in_models,
 )
-from kiln_ai.adapters.model_adapters.litellm_config import (
-    LiteLlmConfig,
-)
-from kiln_ai.adapters.ollama_tools import (
-    get_ollama_connection,
-)
+from kiln_ai.adapters.model_adapters.litellm_config import LiteLlmConfig
+from kiln_ai.adapters.ollama_tools import get_ollama_connection
 from kiln_ai.datamodel import Finetune, Task
 from kiln_ai.datamodel.datamodel_enums import ChatStrategy
-from kiln_ai.datamodel.registry import project_from_id
 from kiln_ai.datamodel.task import RunConfigProperties
 from kiln_ai.utils.config import Config
 from kiln_ai.utils.exhaustive_error import raise_exhaustive_enum_error
+from kiln_ai.utils.project_utils import project_from_id
 
 logger = logging.getLogger(__name__)
 
@@ -37,6 +35,15 @@ async def provider_enabled(provider_name: ModelProviderName) -> bool:
         except Exception:
             return False
 
+    if provider_name == ModelProviderName.docker_model_runner:
+        try:
+            conn = await get_docker_model_runner_connection()
+            return conn is not None and (
+                len(conn.supported_models) > 0 or len(conn.untested_models) > 0
+            )
+        except Exception:
+            return False
+
     provider_warning = provider_warnings.get(provider_name)
     if provider_warning is None:
         return False
@@ -75,30 +82,24 @@ def builtin_model_from(
     name: str, provider_name: str | None = None
 ) -> KilnModelProvider | None:
     """
-    Gets a model and provider from the built-in list of models.
+    Gets a model provider from the built-in list of models.
 
     Args:
         name: The name of the model to get
         provider_name: Optional specific provider to use (defaults to first available)
 
     Returns:
-        A tuple of (provider, model)
-
-    Raises:
-        ValueError: If the model or provider is not found, or if the provider is misconfigured
+        A KilnModelProvider, or None if not found
     """
-    if name not in ModelName.__members__:
-        return None
-
     # Select the model from built_in_models using the name
-    model = next(filter(lambda m: m.name == name, built_in_models))
+    model = next(filter(lambda m: m.name == name, built_in_models), None)
     if model is None:
-        raise ValueError(f"Model {name} not found")
+        return None
 
-    # If a provider is provided, select the provider from the model's provider_config
+    # If a provider is provided, select the appropriate provider. Otherwise, use the first available.
     provider: KilnModelProvider | None = None
     if model.providers is None or len(model.providers) == 0:
-        raise ValueError(f"Model {name} has no providers")
+        return None
     elif provider_name is None:
         provider = model.providers[0]
     else:
@@ -384,6 +385,12 @@ def provider_name_from_id(id: str) -> str:
                 return "Google Vertex AI"
             case ModelProviderName.together_ai:
                 return "Together AI"
+            case ModelProviderName.siliconflow_cn:
+                return "SiliconFlow"
+            case ModelProviderName.cerebras:
+                return "Cerebras"
+            case ModelProviderName.docker_model_runner:
+                return "Docker Model Runner"
             case _:
                 # triggers pyright warning if I miss a case
                 raise_exhaustive_enum_error(enum_id)
@@ -442,4 +449,12 @@ provider_warnings: Dict[ModelProviderName, ModelProviderWarning] = {
         required_config_keys=["together_api_key"],
         message="Attempted to use Together without an API key set. \nGet your API key from https://together.ai/settings/keys",
     ),
+    ModelProviderName.siliconflow_cn: ModelProviderWarning(
+        required_config_keys=["siliconflow_cn_api_key"],
+        message="Attempted to use SiliconFlow without an API key set. \nGet your API key from https://cloud.siliconflow.cn/account/ak",
+    ),
+    ModelProviderName.cerebras: ModelProviderWarning(
+        required_config_keys=["cerebras_api_key"],
+        message="Attempted to use Cerebras without an API key set. \nGet your API key from https://cloud.cerebras.ai/platform",
+    ),
 }

kiln_ai/adapters/remote_config.py

@@ -4,11 +4,12 @@ import logging
 import os
 import threading
 from pathlib import Path
-from typing import List
+from typing import Any, List
 
 import requests
+from pydantic import ValidationError
 
-from .ml_model_list import KilnModel, built_in_models
+from .ml_model_list import KilnModel, KilnModelProvider, built_in_models
 
 logger = logging.getLogger(__name__)
 
@@ -18,21 +19,67 @@ def serialize_config(models: List[KilnModel], path: str | Path) -> None:
     Path(path).write_text(json.dumps(data, indent=2, sort_keys=True))
 
 
-def deserialize_config(path: str | Path) -> List[KilnModel]:
+def deserialize_config_at_path(path: str | Path) -> List[KilnModel]:
     raw = json.loads(Path(path).read_text())
-    model_data = raw.get("model_list", raw if isinstance(raw, list) else [])
-    return [KilnModel.model_validate(item) for item in model_data]
+    return deserialize_config_data(raw)
+
+
+def deserialize_config_data(config_data: Any) -> List[KilnModel]:
+    if not isinstance(config_data, dict):
+        raise ValueError(f"Remote config expected dict, got {type(config_data)}")
+
+    model_list = config_data.get("model_list", None)
+    if not isinstance(model_list, list):
+        raise ValueError(
+            f"Remote config expected list of models, got {type(model_list)}"
+        )
+
+    # We must be careful here, because some of the JSON data may be generated from a forward
+    # version of the code that has newer fields / versions of the fields, that may cause
+    # the current client this code is running on to fail to validate the item into a KilnModel.
+    models = []
+    for model_data in model_list:
+        # We skip any model that fails validation - the models that the client can support
+        # will be pulled from the remote config, but the user will need to update their
+        # client to the latest version to see the newer models that break backwards compatibility.
+        try:
+            providers_list = model_data.get("providers", [])
+
+            providers = []
+            for provider_data in providers_list:
+                try:
+                    provider = KilnModelProvider.model_validate(provider_data)
+                    providers.append(provider)
+                except ValidationError as e:
+                    logger.warning(
+                        "Failed to validate a model provider from remote config. Upgrade Kiln to use this model. Details %s: %s",
+                        provider_data,
+                        e,
+                    )
+
+            # this ensures the model deserialization won't fail because of a bad provider
+            model_data["providers"] = []
+
+            # now we validate the model without its providers
+            model = KilnModel.model_validate(model_data)
+
+            # and we attach back the providers that passed our validation
+            model.providers = providers
+            models.append(model)
+        except ValidationError as e:
+            logger.warning(
+                "Failed to validate a model from remote config. Upgrade Kiln to use this model. Details %s: %s",
+                model_data,
+                e,
+            )
+    return models
 
 
 def load_from_url(url: str) -> List[KilnModel]:
     response = requests.get(url, timeout=10)
     response.raise_for_status()
     data = response.json()
-    if isinstance(data, list):
-        model_data = data
-    else:
-        model_data = data.get("model_list", [])
-    return [KilnModel.model_validate(item) for item in model_data]
+    return deserialize_config_data(data)
 
 
 def dump_builtin_config(path: str | Path) -> None:

kiln_ai/adapters/repair/repair_task.py

@@ -6,7 +6,7 @@ from kiln_ai.adapters.prompt_builders import BasePromptBuilder, prompt_builder_f
 from kiln_ai.datamodel import Priority, Project, Task, TaskRequirement, TaskRun
 
 
-# TODO add evaluator rating
+# We should add evaluator rating
 class RepairTaskInput(BaseModel):
     original_prompt: str
     original_input: str

kiln_ai/adapters/repair/test_repair_task.py

@@ -229,21 +229,20 @@ async def test_mocked_repair_task_run(sample_task, sample_task_run, sample_repai
         "rating": 8,
     }
 
+    run_config = RunConfigProperties(
+        model_name="llama_3_1_8b",
+        model_provider_name="ollama",
+        prompt_id="simple_prompt_builder",
+        structured_output_mode="json_schema",
+    )
+
     with patch.object(LiteLlmAdapter, "_run", new_callable=AsyncMock) as mock_run:
         mock_run.return_value = (
             RunOutput(output=mocked_output, intermediate_outputs=None),
             None,
         )
 
-        adapter = adapter_for_task(
-            repair_task,
-            RunConfigProperties(
-                model_name="llama_3_1_8b",
-                model_provider_name="ollama",
-                prompt_id="simple_prompt_builder",
-                structured_output_mode="json_schema",
-            ),
-        )
+        adapter = adapter_for_task(repair_task, run_config)
 
         run = await adapter.invoke(repair_task_input.model_dump())
 
@@ -264,6 +263,10 @@ async def test_mocked_repair_task_run(sample_task, sample_task_run, sample_repai
     }
     assert run.input_source.type == DataSourceType.human
     assert "created_by" in run.input_source.properties
+    assert run.output.source is not None
+    assert run.output.source.run_config is not None
+    saved_run_config = run.output.source.run_config.model_dump()
+    assert saved_run_config == run_config.model_dump()
 
     # Verify that the mock was called
     mock_run.assert_called_once()

kiln_ai/adapters/run_output.py

@@ -3,9 +3,12 @@ from typing import Dict
 
 from litellm.types.utils import ChoiceLogprobs
 
+from kiln_ai.utils.open_ai_types import ChatCompletionMessageParam
+
 
 @dataclass
 class RunOutput:
     output: Dict | str
     intermediate_outputs: Dict[str, str] | None
     output_logprobs: ChoiceLogprobs | None = None
+    trace: list[ChatCompletionMessageParam] | None = None

kiln_ai/adapters/test_adapter_registry.py

@@ -8,6 +8,7 @@ from kiln_ai.adapters.ml_model_list import ModelProviderName
 from kiln_ai.adapters.model_adapters.base_adapter import AdapterConfig
 from kiln_ai.adapters.model_adapters.litellm_adapter import LiteLlmAdapter
 from kiln_ai.adapters.provider_tools import kiln_model_provider_from
+from kiln_ai.datamodel.datamodel_enums import StructuredOutputMode
 from kiln_ai.datamodel.task import RunConfigProperties
 
 
@@ -16,6 +17,10 @@ def mock_config():
     with patch("kiln_ai.adapters.adapter_registry.Config") as mock:
         mock.shared.return_value.open_ai_api_key = "test-openai-key"
         mock.shared.return_value.open_router_api_key = "test-openrouter-key"
+        mock.shared.return_value.siliconflow_cn_api_key = "test-siliconflow-key"
+        mock.shared.return_value.docker_model_runner_base_url = (
+            "http://localhost:12434/engines/llama.cpp"
+        )
         yield mock
 
 
@@ -85,6 +90,33 @@ def test_openrouter_adapter_creation(mock_config, basic_task):
     }
 
 
+def test_siliconflow_adapter_creation(mock_config, basic_task):
+    adapter = adapter_for_task(
+        kiln_task=basic_task,
+        run_config_properties=RunConfigProperties(
+            model_name="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+            model_provider_name=ModelProviderName.siliconflow_cn,
+            prompt_id="simple_prompt_builder",
+            structured_output_mode="json_schema",
+        ),
+    )
+
+    assert isinstance(adapter, LiteLlmAdapter)
+    assert (
+        adapter.config.run_config_properties.model_name
+        == "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
+    )
+    assert adapter.config.additional_body_options == {"api_key": "test-siliconflow-key"}
+    assert (
+        adapter.config.run_config_properties.model_provider_name
+        == ModelProviderName.siliconflow_cn
+    )
+    assert adapter.config.default_headers == {
+        "HTTP-Referer": "https://kiln.tech/siliconflow",
+        "X-Title": "KilnAI",
+    }
+
+
 @pytest.mark.parametrize(
     "provider",
     [
@@ -109,7 +141,7 @@ def test_openai_compatible_adapter_creation(mock_config, basic_task, provider):
     assert adapter.run_config.model_name == "test-model"
 
 
-# TODO should run for all cases
+# We should run for all cases
 def test_custom_prompt_builder(mock_config, basic_task):
     adapter = adapter_for_task(
         kiln_task=basic_task,
@@ -124,7 +156,7 @@ def test_custom_prompt_builder(mock_config, basic_task):
     assert adapter.run_config.prompt_id == "simple_chain_of_thought_prompt_builder"
 
 
-# TODO should run for all cases
+# We should run for all cases
 def test_tags_passed_through(mock_config, basic_task):
     tags = ["test-tag-1", "test-tag-2"]
     adapter = adapter_for_task(
@@ -232,3 +264,78 @@ async def test_fine_tune_provider(mock_config, basic_task, mock_finetune_from_id
     )
     # The actual model name from the fine tune object
     assert provider.model_id == "test-model"
+
+
+def test_docker_model_runner_adapter_creation(mock_config, basic_task):
+    """Test Docker Model Runner adapter creation with default and custom base URL."""
+    adapter = adapter_for_task(
+        kiln_task=basic_task,
+        run_config_properties=RunConfigProperties(
+            model_name="llama_3_2_3b",
+            model_provider_name=ModelProviderName.docker_model_runner,
+            prompt_id="simple_prompt_builder",
+            structured_output_mode=StructuredOutputMode.json_schema,
+        ),
+    )
+
+    assert isinstance(adapter, LiteLlmAdapter)
+    assert adapter.config.run_config_properties.model_name == "llama_3_2_3b"
+    assert adapter.config.additional_body_options == {"api_key": "DMR"}
+    assert (
+        adapter.config.run_config_properties.model_provider_name
+        == ModelProviderName.docker_model_runner
+    )
+    assert adapter.config.base_url == "http://localhost:12434/engines/llama.cpp/v1"
+    assert adapter.config.default_headers is None
+
+
+def test_docker_model_runner_adapter_creation_with_custom_url(mock_config, basic_task):
+    """Test Docker Model Runner adapter creation with custom base URL."""
+    mock_config.shared.return_value.docker_model_runner_base_url = (
+        "http://custom:8080/engines/llama.cpp"
+    )
+
+    adapter = adapter_for_task(
+        kiln_task=basic_task,
+        run_config_properties=RunConfigProperties(
+            model_name="llama_3_2_3b",
+            model_provider_name=ModelProviderName.docker_model_runner,
+            prompt_id="simple_prompt_builder",
+            structured_output_mode=StructuredOutputMode.json_schema,
+        ),
+    )
+
+    assert isinstance(adapter, LiteLlmAdapter)
+    assert adapter.config.run_config_properties.model_name == "llama_3_2_3b"
+    assert adapter.config.additional_body_options == {"api_key": "DMR"}
+    assert (
+        adapter.config.run_config_properties.model_provider_name
+        == ModelProviderName.docker_model_runner
+    )
+    assert adapter.config.base_url == "http://custom:8080/engines/llama.cpp/v1"
+    assert adapter.config.default_headers is None
+
+
+def test_docker_model_runner_adapter_creation_with_none_url(mock_config, basic_task):
+    """Test Docker Model Runner adapter creation when config URL is None."""
+    mock_config.shared.return_value.docker_model_runner_base_url = None
+
+    adapter = adapter_for_task(
+        kiln_task=basic_task,
+        run_config_properties=RunConfigProperties(
+            model_name="llama_3_2_3b",
+            model_provider_name=ModelProviderName.docker_model_runner,
+            prompt_id="simple_prompt_builder",
+            structured_output_mode=StructuredOutputMode.json_schema,
+        ),
+    )
+
+    assert isinstance(adapter, LiteLlmAdapter)
+    assert adapter.config.run_config_properties.model_name == "llama_3_2_3b"
+    assert adapter.config.additional_body_options == {"api_key": "DMR"}
+    assert (
+        adapter.config.run_config_properties.model_provider_name
+        == ModelProviderName.docker_model_runner
+    )
+    assert adapter.config.base_url == "http://localhost:12434/engines/llama.cpp/v1"
+    assert adapter.config.default_headers is None