kiln-ai 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

kiln_ai/adapters/provider_tools.py

@@ -9,8 +9,8 @@ from kiln_ai.adapters.ml_model_list import (
     StructuredOutputMode,
     built_in_models,
 )
-from kiln_ai.adapters.model_adapters.openai_compatible_config import (
-    OpenAICompatibleConfig,
+from kiln_ai.adapters.model_adapters.litellm_config import (
+    LiteLlmConfig,
 )
 from kiln_ai.adapters.ollama_tools import (
     get_ollama_connection,
@@ -153,7 +153,7 @@ def kiln_model_provider_from(
         return finetune_provider_model(name)
 
     if provider_name == ModelProviderName.openai_compatible:
-        return openai_compatible_provider_model(name)
+        return lite_llm_provider_model(name)
 
     built_in_model = builtin_model_from(name, provider_name)
     if built_in_model:
@@ -175,13 +175,13 @@ def kiln_model_provider_from(
         supports_structured_output=False,
         supports_data_gen=False,
         untested_model=True,
-        provider_options=provider_options_for_custom_model(name, provider_name),
+        model_id=name,
     )
 
 
-def openai_compatible_config(
+def lite_llm_config(
     model_id: str,
-) -> OpenAICompatibleConfig:
+) -> LiteLlmConfig:
     try:
         openai_provider_name, model_id = model_id.split("::")
     except Exception:
@@ -205,22 +205,23 @@ def openai_compatible_config(
             f"OpenAI compatible provider {openai_provider_name} has no base URL"
         )
 
-    return OpenAICompatibleConfig(
-        api_key=api_key,
+    return LiteLlmConfig(
+        # OpenAI compatible, with a custom base URL
         model_name=model_id,
         provider_name=ModelProviderName.openai_compatible,
         base_url=base_url,
+        additional_body_options={
+            "api_key": api_key,
+        },
     )
 
 
-def openai_compatible_provider_model(
+def lite_llm_provider_model(
     model_id: str,
 ) -> KilnModelProvider:
     return KilnModelProvider(
         name=ModelProviderName.openai_compatible,
-        provider_options={
-            "model": model_id,
-        },
+        model_id=model_id,
         supports_structured_output=False,
         supports_data_gen=False,
         untested_model=True,
@@ -264,9 +265,7 @@ def finetune_provider_model(
     provider = ModelProviderName[fine_tune.provider]
     model_provider = KilnModelProvider(
         name=provider,
-        provider_options={
-            "model": fine_tune.fine_tune_model_id,
-        },
+        model_id=fine_tune.fine_tune_model_id,
     )
 
     if fine_tune.structured_output_mode is not None:
@@ -331,6 +330,18 @@ def provider_name_from_id(id: str) -> str:
                 return "Custom Models"
             case ModelProviderName.openai_compatible:
                 return "OpenAI Compatible"
+            case ModelProviderName.azure_openai:
+                return "Azure OpenAI"
+            case ModelProviderName.gemini_api:
+                return "Gemini API"
+            case ModelProviderName.anthropic:
+                return "Anthropic"
+            case ModelProviderName.huggingface:
+                return "Hugging Face"
+            case ModelProviderName.vertex:
+                return "Google Vertex AI"
+            case ModelProviderName.together_ai:
+                return "Together AI"
             case _:
                 # triggers pyright warning if I miss a case
                 raise_exhaustive_enum_error(enum_id)
@@ -338,49 +349,6 @@ def provider_name_from_id(id: str) -> str:
     return "Unknown provider: " + id
 
 
-def provider_options_for_custom_model(
-    model_name: str, provider_name: str
-) -> Dict[str, str]:
-    """
-    Generated model provider options for a custom model. Each has their own format/options.
-    """
-
-    if provider_name not in ModelProviderName.__members__:
-        raise ValueError(f"Invalid provider name: {provider_name}")
-
-    enum_id = ModelProviderName(provider_name)
-    match enum_id:
-        case ModelProviderName.amazon_bedrock:
-            # us-west-2 is the only region consistently supported by Bedrock
-            return {"model": model_name, "region_name": "us-west-2"}
-        case (
-            ModelProviderName.openai
-            | ModelProviderName.ollama
-            | ModelProviderName.fireworks_ai
-            | ModelProviderName.openrouter
-            | ModelProviderName.groq
-        ):
-            return {"model": model_name}
-        case ModelProviderName.kiln_custom_registry:
-            raise ValueError(
-                "Custom models from registry should be parsed into provider/model before calling this."
-            )
-        case ModelProviderName.kiln_fine_tune:
-            raise ValueError(
-                "Fine tuned models should populate provider options via another path"
-            )
-        case ModelProviderName.openai_compatible:
-            raise ValueError(
-                "OpenAI compatible models should populate provider options via another path"
-            )
-        case _:
-            # triggers pyright warning if I miss a case
-            raise_exhaustive_enum_error(enum_id)
-
-    # Won't reach this, type checking will catch missed values
-    return {"model": model_name}
-
-
 @dataclass
 class ModelProviderWarning:
     required_config_keys: List[str]
@@ -408,4 +376,28 @@ provider_warnings: Dict[ModelProviderName, ModelProviderWarning] = {
         required_config_keys=["fireworks_api_key", "fireworks_account_id"],
         message="Attempted to use Fireworks without an API key and account ID set. \nGet your API key from https://fireworks.ai/account/api-keys and your account ID from https://fireworks.ai/account/profile",
     ),
+    ModelProviderName.anthropic: ModelProviderWarning(
+        required_config_keys=["anthropic_api_key"],
+        message="Attempted to use Anthropic without an API key set. \nGet your API key from https://console.anthropic.com/settings/keys",
+    ),
+    ModelProviderName.gemini_api: ModelProviderWarning(
+        required_config_keys=["gemini_api_key"],
+        message="Attempted to use Gemini without an API key set. \nGet your API key from https://aistudio.google.com/app/apikey",
+    ),
+    ModelProviderName.azure_openai: ModelProviderWarning(
+        required_config_keys=["azure_openai_api_key", "azure_openai_endpoint"],
+        message="Attempted to use Azure OpenAI without an API key and endpoint set. Configure these in settings.",
+    ),
+    ModelProviderName.huggingface: ModelProviderWarning(
+        required_config_keys=["huggingface_api_key"],
+        message="Attempted to use Hugging Face without an API key set. \nGet your API key from https://huggingface.co/settings/tokens",
+    ),
+    ModelProviderName.vertex: ModelProviderWarning(
+        required_config_keys=["vertex_project_id"],
+        message="Attempted to use Vertex without a project ID set. \nGet your project ID from the Vertex AI console.",
+    ),
+    ModelProviderName.together_ai: 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",
+    ),
 }

kiln_ai/adapters/repair/test_repair_task.py

@@ -7,7 +7,7 @@ from pydantic import ValidationError
 
 from kiln_ai.adapters.adapter_registry import adapter_for_task
 from kiln_ai.adapters.model_adapters.base_adapter import RunOutput
-from kiln_ai.adapters.model_adapters.langchain_adapters import LangchainAdapter
+from kiln_ai.adapters.model_adapters.litellm_adapter import LiteLlmAdapter
 from kiln_ai.adapters.repair.repair_task import (
     RepairTaskInput,
     RepairTaskRun,
@@ -217,7 +217,7 @@ async def test_mocked_repair_task_run(sample_task, sample_task_run, sample_repai
         "rating": 8,
     }
 
-    with patch.object(LangchainAdapter, "_run", new_callable=AsyncMock) as mock_run:
+    with patch.object(LiteLlmAdapter, "_run", new_callable=AsyncMock) as mock_run:
         mock_run.return_value = RunOutput(
             output=mocked_output, intermediate_outputs=None
         )
@@ -235,7 +235,7 @@ async def test_mocked_repair_task_run(sample_task, sample_task_run, sample_repai
     parsed_output = json.loads(run.output.output)
     assert parsed_output == mocked_output
     assert run.output.source.properties == {
-        "adapter_name": "kiln_langchain_adapter",
+        "adapter_name": "kiln_openai_compatible_adapter",
         "model_name": "llama_3_1_8b",
         "model_provider": "ollama",
         "prompt_id": "simple_prompt_builder",

kiln_ai/adapters/run_output.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import Dict
 
-from openai.types.chat.chat_completion import ChoiceLogprobs
+from litellm.types.utils import ChoiceLogprobs
 
 
 @dataclass

kiln_ai/adapters/test_adapter_registry.py

@@ -6,8 +6,7 @@ from kiln_ai import datamodel
 from kiln_ai.adapters.adapter_registry import adapter_for_task
 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.langchain_adapters import LangchainAdapter
-from kiln_ai.adapters.model_adapters.openai_model_adapter import OpenAICompatibleAdapter
+from kiln_ai.adapters.model_adapters.litellm_adapter import LiteLlmAdapter
 from kiln_ai.adapters.prompt_builders import BasePromptBuilder
 from kiln_ai.adapters.provider_tools import kiln_model_provider_from
 
@@ -44,9 +43,9 @@ def test_openai_adapter_creation(mock_config, basic_task):
         kiln_task=basic_task, model_name="gpt-4", provider=ModelProviderName.openai
     )
 
-    assert isinstance(adapter, OpenAICompatibleAdapter)
+    assert isinstance(adapter, LiteLlmAdapter)
     assert adapter.config.model_name == "gpt-4"
-    assert adapter.config.api_key == "test-openai-key"
+    assert adapter.config.additional_body_options == {"api_key": "test-openai-key"}
     assert adapter.config.provider_name == ModelProviderName.openai
     assert adapter.config.base_url is None  # OpenAI url is default
     assert adapter.config.default_headers is None
@@ -59,11 +58,10 @@ def test_openrouter_adapter_creation(mock_config, basic_task):
         provider=ModelProviderName.openrouter,
     )
 
-    assert isinstance(adapter, OpenAICompatibleAdapter)
+    assert isinstance(adapter, LiteLlmAdapter)
     assert adapter.config.model_name == "anthropic/claude-3-opus"
-    assert adapter.config.api_key == "test-openrouter-key"
+    assert adapter.config.additional_body_options == {"api_key": "test-openrouter-key"}
     assert adapter.config.provider_name == ModelProviderName.openrouter
-    assert adapter.config.base_url == "https://openrouter.ai/api/v1"
     assert adapter.config.default_headers == {
         "HTTP-Referer": "https://getkiln.ai/openrouter",
         "X-Title": "KilnAI",
@@ -79,12 +77,12 @@ def test_openrouter_adapter_creation(mock_config, basic_task):
         ModelProviderName.fireworks_ai,
     ],
 )
-def test_langchain_adapter_creation(mock_config, basic_task, provider):
+def test_openai_compatible_adapter_creation(mock_config, basic_task, provider):
     adapter = adapter_for_task(
         kiln_task=basic_task, model_name="test-model", provider=provider
     )
 
-    assert isinstance(adapter, LangchainAdapter)
+    assert isinstance(adapter, LiteLlmAdapter)
     assert adapter.run_config.model_name == "test-model"
 
 
@@ -122,10 +120,12 @@ def test_invalid_provider(mock_config, basic_task):
         )
 
 
-@patch("kiln_ai.adapters.adapter_registry.openai_compatible_config")
+@patch("kiln_ai.adapters.adapter_registry.lite_llm_config")
 def test_openai_compatible_adapter(mock_compatible_config, mock_config, basic_task):
     mock_compatible_config.return_value.model_name = "test-model"
-    mock_compatible_config.return_value.api_key = "test-key"
+    mock_compatible_config.return_value.additional_body_options = {
+        "api_key": "test-key"
+    }
     mock_compatible_config.return_value.base_url = "https://test.com/v1"
     mock_compatible_config.return_value.provider_name = "CustomProvider99"
 
@@ -135,12 +135,9 @@ def test_openai_compatible_adapter(mock_compatible_config, mock_config, basic_ta
         provider=ModelProviderName.openai_compatible,
     )
 
-    assert isinstance(adapter, OpenAICompatibleAdapter)
+    assert isinstance(adapter, LiteLlmAdapter)
     mock_compatible_config.assert_called_once_with("provider::test-model")
-    assert adapter.config.model_name == "test-model"
-    assert adapter.config.api_key == "test-key"
-    assert adapter.config.base_url == "https://test.com/v1"
-    assert adapter.config.provider_name == "CustomProvider99"
+    assert adapter.config == mock_compatible_config.return_value
 
 
 def test_custom_openai_compatible_provider(mock_config, basic_task):
@@ -150,9 +147,9 @@ def test_custom_openai_compatible_provider(mock_config, basic_task):
         provider=ModelProviderName.kiln_custom_registry,
     )
 
-    assert isinstance(adapter, OpenAICompatibleAdapter)
+    assert isinstance(adapter, LiteLlmAdapter)
     assert adapter.config.model_name == "openai::test-model"
-    assert adapter.config.api_key == "test-openai-key"
+    assert adapter.config.additional_body_options == {"api_key": "test-openai-key"}
     assert adapter.config.base_url is None  # openai is none
     assert adapter.config.provider_name == ModelProviderName.kiln_custom_registry
 
@@ -165,7 +162,7 @@ async def test_fine_tune_provider(mock_config, basic_task, mock_finetune_from_id
     )
 
     mock_finetune_from_id.assert_called_once_with("proj::task::tune")
-    assert isinstance(adapter, OpenAICompatibleAdapter)
+    assert isinstance(adapter, LiteLlmAdapter)
     assert adapter.config.provider_name == ModelProviderName.kiln_fine_tune
     # Kiln model name here, but the underlying openai model id below
     assert adapter.config.model_name == "proj::task::tune"
@@ -174,4 +171,4 @@ async def test_fine_tune_provider(mock_config, basic_task, mock_finetune_from_id
         "proj::task::tune", provider_name=ModelProviderName.kiln_fine_tune
     )
     # The actual model name from the fine tune object
-    assert provider.provider_options["model"] == "test-model"
+    assert provider.model_id == "test-model"

kiln_ai/adapters/test_generate_docs.py

@@ -58,8 +58,8 @@ def test_generate_model_table():
         table.append(row)
 
     # Print the table (useful for documentation)
-    logger.info("\nModel Capability Matrix:\n")
-    logger.info("\n".join(table))
+    print("\nModel Capability Matrix:\n")
+    print("\n".join(table))
 
     # Basic assertions to ensure the table is well-formed
     assert len(table) > 2, "Table should have header and at least one row"

kiln_ai/adapters/test_prompt_adaptors.py

@@ -1,13 +1,17 @@
 import os
 from pathlib import Path
+from unittest.mock import patch
 
 import pytest
-from langchain_core.language_models.fake_chat_models import FakeListChatModel
+from litellm.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.langchain_adapters import LangchainAdapter
+from kiln_ai.adapters.model_adapters.litellm_adapter import (
+    LiteLlmAdapter,
+    LiteLlmConfig,
+)
 from kiln_ai.adapters.ollama_tools import ollama_online
 from kiln_ai.adapters.prompt_builders import (
     BasePromptBuilder,
@@ -20,6 +24,9 @@ def get_all_models_and_providers():
     model_provider_pairs = []
     for model in built_in_models:
         for provider in model.providers:
+            if not provider.model_id:
+                # it's possible for models to not have an ID (fine-tune only model)
+                continue
             model_provider_pairs.append((model.name, provider.name))
     return model_provider_pairs
 
@@ -106,23 +113,27 @@ async def test_amazon_bedrock(tmp_path):
     await run_simple_test(tmp_path, "llama_3_1_8b", "amazon_bedrock")
 
 
-async def test_mock(tmp_path):
-    task = build_test_task(tmp_path)
-    mockChatModel = FakeListChatModel(responses=["mock response"])
-    adapter = LangchainAdapter(
-        task,
-        custom_model=mockChatModel,
-        provider="ollama",
-    )
-    run = await adapter.invoke("You are a mock, send me the response!")
-    assert "mock response" in run.output.output
-
-
 async def test_mock_returning_run(tmp_path):
     task = build_test_task(tmp_path)
-    mockChatModel = FakeListChatModel(responses=["mock response"])
-    adapter = LangchainAdapter(task, custom_model=mockChatModel, provider="ollama")
-    run = await adapter.invoke("You are a mock, send me the response!")
+    with patch("litellm.acompletion") as mock_acompletion:
+        # Configure the mock to return a properly structured response
+        mock_acompletion.return_value = ModelResponse(
+            model="custom_model",
+            choices=[{"message": {"content": "mock response"}}],
+        )
+
+        adapter = LiteLlmAdapter(
+            config=LiteLlmConfig(
+                model_name="custom_model",
+                provider_name="ollama",
+                base_url="http://localhost:11434",
+                additional_body_options={"api_key": "test_key"},
+            ),
+            kiln_task=task,
+        )
+
+        run = await adapter.invoke("You are a mock, send me the response!")
+
     assert run.output.output == "mock response"
     assert run is not None
     assert run.id is not None
@@ -130,8 +141,8 @@ async def test_mock_returning_run(tmp_path):
     assert run.output.output == "mock response"
     assert "created_by" in run.input_source.properties
     assert run.output.source.properties == {
-        "adapter_name": "kiln_langchain_adapter",
-        "model_name": "custom.langchain:unknown_model",
+        "adapter_name": "kiln_openai_compatible_adapter",
+        "model_name": "custom_model",
         "model_provider": "ollama",
         "prompt_id": "simple_prompt_builder",
     }

kiln_ai/adapters/test_provider_tools.py

@@ -17,12 +17,11 @@ from kiln_ai.adapters.provider_tools import (
     finetune_provider_model,
     get_model_and_provider,
     kiln_model_provider_from,
-    openai_compatible_config,
-    openai_compatible_provider_model,
+    lite_llm_config,
+    lite_llm_provider_model,
     parse_custom_model_id,
     provider_enabled,
     provider_name_from_id,
-    provider_options_for_custom_model,
     provider_warnings,
 )
 from kiln_ai.datamodel import Finetune, StructuredOutputMode, Task
@@ -186,7 +185,7 @@ def test_get_model_and_provider_valid():
     assert provider is not None
     assert model.name == ModelName.phi_3_5
     assert provider.name == ModelProviderName.ollama
-    assert provider.provider_options["model"] == "phi3.5"
+    assert provider.model_id == "phi3.5"
 
 
 def test_get_model_and_provider_invalid_model():
@@ -227,7 +226,7 @@ def test_get_model_and_provider_multiple_providers():
     assert provider is not None
     assert model.name == ModelName.llama_3_3_70b
     assert provider.name == ModelProviderName.groq
-    assert provider.provider_options["model"] == "llama-3.3-70b-versatile"
+    assert provider.model_id == "llama-3.3-70b-versatile"
 
 
 @pytest.mark.asyncio
@@ -324,59 +323,7 @@ async def test_kiln_model_provider_from_custom_model_valid(mock_config):
     assert provider.supports_structured_output is False
     assert provider.supports_data_gen is False
     assert provider.untested_model is True
-    assert "model" in provider.provider_options
-    assert provider.provider_options["model"] == "custom_model"
-
-
-def test_provider_options_for_custom_model_basic():
-    """Test basic case with custom model name"""
-    options = provider_options_for_custom_model(
-        "custom_model_name", ModelProviderName.openai
-    )
-    assert options == {"model": "custom_model_name"}
-
-
-def test_provider_options_for_custom_model_bedrock():
-    """Test Amazon Bedrock provider options"""
-    options = provider_options_for_custom_model(
-        ModelName.llama_3_1_8b, ModelProviderName.amazon_bedrock
-    )
-    assert options == {"model": ModelName.llama_3_1_8b, "region_name": "us-west-2"}
-
-
-@pytest.mark.parametrize(
-    "provider",
-    [
-        ModelProviderName.openai,
-        ModelProviderName.ollama,
-        ModelProviderName.fireworks_ai,
-        ModelProviderName.openrouter,
-        ModelProviderName.groq,
-    ],
-)
-def test_provider_options_for_custom_model_simple_providers(provider):
-    """Test providers that just need model name"""
-
-    options = provider_options_for_custom_model(ModelName.llama_3_1_8b, provider)
-    assert options == {"model": ModelName.llama_3_1_8b}
-
-
-def test_provider_options_for_custom_model_kiln_fine_tune():
-    """Test that kiln_fine_tune raises appropriate error"""
-    with pytest.raises(ValueError) as exc_info:
-        provider_options_for_custom_model(
-            "model_name", ModelProviderName.kiln_fine_tune
-        )
-    assert (
-        str(exc_info.value)
-        == "Fine tuned models should populate provider options via another path"
-    )
-
-
-def test_provider_options_for_custom_model_invalid_enum():
-    """Test handling of invalid enum value"""
-    with pytest.raises(ValueError):
-        provider_options_for_custom_model("model_name", "invalid_enum_value")
+    assert provider.model_id == "custom_model"
 
 
 @pytest.mark.asyncio
@@ -393,7 +340,7 @@ async def test_kiln_model_provider_from_custom_registry(mock_config):
     assert provider.supports_structured_output is False
     assert provider.supports_data_gen is False
     assert provider.untested_model is True
-    assert provider.provider_options == {"model": "gpt-4-turbo"}
+    assert provider.model_id == "gpt-4-turbo"
 
 
 @pytest.mark.asyncio
@@ -412,7 +359,7 @@ async def test_builtin_model_from_valid_model_default_provider(mock_config):
 
     assert provider is not None
     assert provider.name == ModelProviderName.ollama
-    assert provider.provider_options["model"] == "phi3.5"
+    assert provider.model_id == "phi3.5"
 
 
 @pytest.mark.asyncio
@@ -426,7 +373,7 @@ async def test_builtin_model_from_valid_model_specific_provider(mock_config):
 
     assert provider is not None
     assert provider.name == ModelProviderName.groq
-    assert provider.provider_options["model"] == "llama-3.3-70b-versatile"
+    assert provider.model_id == "llama-3.3-70b-versatile"
 
 
 @pytest.mark.asyncio
@@ -477,7 +424,7 @@ def test_finetune_provider_model_success(mock_project, mock_task, mock_finetune)
     provider = finetune_provider_model(model_id)
 
     assert provider.name == ModelProviderName.openai
-    assert provider.provider_options == {"model": "ft:gpt-3.5-turbo:custom:model-123"}
+    assert provider.model_id == "ft:gpt-3.5-turbo:custom:model-123"
     assert provider.structured_output_mode == StructuredOutputMode.json_schema
 
 
@@ -573,7 +520,7 @@ def test_finetune_provider_model_structured_mode(
     provider = finetune_provider_model("project-123::task-456::finetune-789")
 
     assert provider.name == provider_name
-    assert provider.provider_options == {"model": "fireworks-model-123"}
+    assert provider.model_id == "fireworks-model-123"
     assert provider.structured_output_mode == expected_mode
 
 
@@ -581,69 +528,67 @@ def test_openai_compatible_provider_config(mock_shared_config):
     """Test successful creation of an OpenAI compatible provider"""
     model_id = "test_provider::gpt-4"
 
-    config = openai_compatible_config(model_id)
+    config = lite_llm_config(model_id)
 
     assert config.provider_name == ModelProviderName.openai_compatible
     assert config.model_name == "gpt-4"
-    assert config.api_key == "test-key"
+    assert config.additional_body_options == {"api_key": "test-key"}
     assert config.base_url == "https://api.test.com"
 
 
-def test_openai_compatible_provider_model_success(mock_shared_config):
+def test_litellm_provider_model_success(mock_shared_config):
     """Test successful creation of an OpenAI compatible provider"""
     model_id = "test_provider::gpt-4"
 
-    provider = openai_compatible_provider_model(model_id)
+    provider = lite_llm_provider_model(model_id)
 
     assert provider.name == ModelProviderName.openai_compatible
-    assert provider.provider_options == {
-        "model": model_id,
-    }
+    assert provider.model_id == model_id
     assert provider.supports_structured_output is False
     assert provider.supports_data_gen is False
     assert provider.untested_model is True
 
 
-def test_openai_compatible_config_no_api_key(mock_shared_config):
+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)"""
     model_id = "no_key_provider::gpt-4"
 
-    config = openai_compatible_config(model_id)
+    config = lite_llm_config(model_id)
 
     assert config.provider_name == ModelProviderName.openai_compatible
     assert config.model_name == "gpt-4"
-    assert config.api_key is None
+    assert config.additional_body_options == {"api_key": None}
     assert config.base_url == "https://api.nokey.com"
 
 
-def test_openai_compatible_config_invalid_id():
+def test_lite_llm_config_invalid_id():
     """Test handling of invalid model ID format"""
     with pytest.raises(ValueError) as exc_info:
-        openai_compatible_config("invalid-id-format")
+        lite_llm_config("invalid-id-format")
     assert (
         str(exc_info.value) == "Invalid openai compatible model ID: invalid-id-format"
     )
 
 
-def test_openai_compatible_config_no_providers(mock_shared_config):
+def test_lite_llm_config_no_providers(mock_shared_config):
     """Test handling when no providers are configured"""
     mock_shared_config.return_value.openai_compatible_providers = None
 
     with pytest.raises(ValueError) as exc_info:
-        openai_compatible_config("test_provider::gpt-4")
+        lite_llm_config("test_provider::gpt-4")
     assert str(exc_info.value) == "OpenAI compatible provider test_provider not found"
 
 
-def test_openai_compatible_config_provider_not_found(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:
-        openai_compatible_config("unknown_provider::gpt-4")
+        lite_llm_config("unknown_provider::gpt-4")
     assert (
         str(exc_info.value) == "OpenAI compatible provider unknown_provider not found"
     )
 
 
-def test_openai_compatible_config_no_base_url(mock_shared_config):
+def test_lite_llm_config_no_base_url(mock_shared_config):
     """Test handling of provider without base URL"""
     mock_shared_config.return_value.openai_compatible_providers = [
         {
@@ -653,7 +598,7 @@ def test_openai_compatible_config_no_base_url(mock_shared_config):
     ]
 
     with pytest.raises(ValueError) as exc_info:
-        openai_compatible_config("test_provider::gpt-4")
+        lite_llm_config("test_provider::gpt-4")
     assert (
         str(exc_info.value)
         == "OpenAI compatible provider test_provider has no base URL"

kiln_ai/datamodel/basemodel.py

@@ -268,6 +268,8 @@ class KilnParentedModel(KilnBaseModel, metaclass=ABCMeta):
         )
         if parent_path is None:
             return None
+        if not parent_path.exists():
+            return None
         loaded_parent = self.__class__.parent_type().load_from_file(parent_path)
         self.parent = loaded_parent
         return loaded_parent

kiln_ai/datamodel/datamodel_enums.py

@@ -30,6 +30,7 @@ class StructuredOutputMode(str, Enum):
     - json_mode: request json using API's JSON mode, which should return valid JSON, but isn't checking/passing the schema
     - json_instructions: append instructions to the prompt to request json matching the schema. No API capabilities are used. You should have a custom parser on these models as they will be returning strings.
     - json_instruction_and_object: append instructions to the prompt to request json matching the schema. Also request the response as json_mode via API capabilities (returning dictionaries).
+    - json_custom_instructions: The model should output JSON, but custom instructions are already included in the system prompt. Don't append additional JSON instructions.
     """
 
     default = "default"
@@ -39,6 +40,7 @@ class StructuredOutputMode(str, Enum):
     json_mode = "json_mode"
     json_instructions = "json_instructions"
     json_instruction_and_object = "json_instruction_and_object"
+    json_custom_instructions = "json_custom_instructions"
 
 
 class FineTuneStatusType(str, Enum):