freeplay 0.2.42__py3-none-any.whl → 0.3.0a2__py3-none-any.whl

freeplay/utils.py

@@ -1,19 +1,27 @@
-from typing import Dict, Union, Optional
+from typing import Dict, Union, Optional, Any
 import importlib.metadata
 import platform
 
 import pystache  # type: ignore
-from pydantic import ValidationError
 
 from .errors import FreeplayError, FreeplayConfigurationError
-from .model import PydanticInputVariables, InputVariables
+from .model import InputVariables
+
+
+# Validate that the variables are of the correct type, and do not include functions, dates, classes or None values.
+def all_valid(obj: Any) -> bool:
+    if isinstance(obj, (int, str, bool)):
+        return True
+    elif isinstance(obj, list):
+        return all(all_valid(item) for item in obj)
+    elif isinstance(obj, dict):
+        return all(isinstance(key, str) and all_valid(value) for key, value in obj.items())
+    else:
+        return False
 
 
 def bind_template_variables(template: str, variables: InputVariables) -> str:
-    # Validate that the variables are of the correct type, and do not include functions or None values.
-    try:
-        PydanticInputVariables.model_validate(variables)
-    except ValidationError as err:
+    if not all_valid(variables):
         raise FreeplayError(
             'Variables must be a string, number, bool, or a possibly nested'
             ' list or dict of strings, numbers and booleans.'

{freeplay-0.2.42.dist-info → freeplay-0.3.0a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: freeplay
-Version: 0.2.42
+Version: 0.3.0a2
 Summary: 
 License: MIT
 Author: FreePlay Engineering
@@ -13,10 +13,8 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: anthropic (>=0.20.0,<0.21.0)
 Requires-Dist: click (==8.1.7)
 Requires-Dist: dacite (>=1.8.0,<2.0.0)
-Requires-Dist: openai (>=1,<2)
 Requires-Dist: pystache (>=0.6.5,<0.7.0)
 Requires-Dist: requests (>=2.20.0,<3.0.0dev)
 Description-Content-Type: text/markdown

freeplay-0.3.0a2.dist-info/RECORD

@@ -0,0 +1,20 @@
+freeplay/__init__.py,sha256=_Uk0dUfn59IuToFeFXlhmA1-ULoA3uBWkg8DGbVomhw,346
+freeplay/api_support.py,sha256=Tmc6VRcmPcIgXrDNJXz0VbBD969t5QHAyV3yZlMsYRI,2331
+freeplay/errors.py,sha256=bPqsw32YX-xSr7O-G49M0sSFF7mq-YF1WGq928UV47s,631
+freeplay/freeplay.py,sha256=vwtgLNcHnXTAjyuXU1cOjvYuLBqcZ-RQDAjdFAKh7q0,1479
+freeplay/freeplay_cli.py,sha256=lmdsYwzdpWmUKHz_ieCzB-e6j1EnDHlVw3XIEyP_NEk,3460
+freeplay/llm_parameters.py,sha256=bQbfuC8EICF0XMZQa5pwI3FkQqxmCUVqHO3gYHy3Tg8,898
+freeplay/model.py,sha256=pC24wUsedD4RTI4k1BcYuDjizroeEHINH6FtEa_RLCk,384
+freeplay/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+freeplay/resources/customer_feedback.py,sha256=aTM7Eez7iYmjXSpRqkHxf4pi6xBrzVnMiQCEJVfPGvg,527
+freeplay/resources/prompts.py,sha256=MvrB7rAuHMzRyz6kH9NqfD5Yt33g-pmK7x0tVlyM2Cs,12476
+freeplay/resources/recordings.py,sha256=6hrunYZtWFgGBZx4HzZRKcEYCzHbmaBVH48lBcXrL3w,5181
+freeplay/resources/sessions.py,sha256=ioWdeTM9BSrEWKrFH66ysQIw5kCTlCVopJDmWtFgHz0,868
+freeplay/resources/test_runs.py,sha256=2NAwoW_Yx7K8YM7QyQ3sv9dN6p0gjNgUAR7wSzLYP6w,1452
+freeplay/support.py,sha256=7BizelIEIaSRFj2IL53-RQkjncUNlUS-DPUln2VxoJg,4532
+freeplay/utils.py,sha256=8ZncuwCnzsAhRsaoxOMGa0Py8kXqGHlB9Avr3n79fk0,2064
+freeplay-0.3.0a2.dist-info/LICENSE,sha256=_jzIw45hB1XHGxiQ8leZ0GH_X7bR_a8qgxaqnHbCUOo,1064
+freeplay-0.3.0a2.dist-info/METADATA,sha256=btKL7QhbCkbZKOo_EplzS33-fsoSH8q66iAnaYI_1iY,1604
+freeplay-0.3.0a2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+freeplay-0.3.0a2.dist-info/entry_points.txt,sha256=32s3rf2UUCqiJT4jnClEXZhdXlvl30uwpcxz-Gsy4UU,54
+freeplay-0.3.0a2.dist-info/RECORD,,

{freeplay-0.2.42.dist-info → freeplay-0.3.0a2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.8.1
 Root-Is-Purelib: true
 Tag: py3-none-any

freeplay/completions.py

@@ -1,56 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, TypedDict
-
-from openai.types.chat.chat_completion_chunk import ChoiceDeltaFunctionCall
-
-from .llm_parameters import LLMParameters
-
-
-class ChatMessage(TypedDict):
-    role: str
-    content: str
-
-
-class OpenAIFunctionCall(TypedDict):
-    name: str
-    arguments: str
-
-
-@dataclass
-class CompletionResponse:
-    content: str
-    is_complete: bool
-    openai_function_call: Optional[OpenAIFunctionCall] = None
-
-
-@dataclass
-class ChatCompletionResponse:
-    content: str
-    is_complete: bool
-    message_history: List[ChatMessage]
-
-
-@dataclass
-class PromptTemplateWithMetadata:
-    prompt_template_id: str
-    prompt_template_version_id: str
-
-    name: str
-    content: str
-    flavor_name: Optional[str]
-    params: Optional[Dict[str, Any]]
-
-    def get_params(self) -> LLMParameters:
-        return LLMParameters.empty() if self.params is None else LLMParameters(self.params)
-
-
-@dataclass
-class PromptTemplates:
-    templates: List[PromptTemplateWithMetadata]
-
-
-@dataclass
-class CompletionChunk:
-    text: str
-    is_complete: bool
-    openai_function_call: Optional[ChoiceDeltaFunctionCall] = None

freeplay/flavors.py

@@ -1,459 +0,0 @@
-import json
-from abc import abstractmethod, ABC
-from copy import copy
-from typing import cast, Any, Dict, Generator, List, Optional, Union
-
-import anthropic
-import openai
-from openai import AuthenticationError, BadRequestError, Stream
-from openai.types.chat import ChatCompletion, ChatCompletionChunk, ChatCompletionMessageParam
-
-from .completions import CompletionChunk, PromptTemplateWithMetadata, CompletionResponse, ChatCompletionResponse, \
-    ChatMessage, OpenAIFunctionCall
-from .errors import FreeplayConfigurationError, LLMClientError, LLMServerError, FreeplayError
-from .llm_parameters import LLMParameters
-from .model import InputVariables
-from .provider_config import AnthropicConfig, AzureConfig, OpenAIConfig, ProviderConfig
-from .utils import bind_template_variables
-
-
-class Flavor(ABC):
-    @classmethod
-    def get_by_name(cls, flavor_name: str) -> 'Flavor':
-        if flavor_name == OpenAIChat.record_format_type:
-            return OpenAIChat()
-        elif flavor_name == AzureOpenAIChat.record_format_type:
-            return AzureOpenAIChat()
-        elif flavor_name == AnthropicClaudeChat.record_format_type:
-            return AnthropicClaudeChat()
-        else:
-            raise FreeplayConfigurationError(
-                f'Configured flavor ({flavor_name}) not found in SDK. Please update your SDK version or configure '
-                'a different model in the Freeplay UI.')
-
-    @property
-    @abstractmethod
-    def provider(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    @abstractmethod
-    def record_format_type(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    def _model_params_with_defaults(self) -> LLMParameters:
-        return LLMParameters.empty()
-
-    @abstractmethod
-    def format(self, prompt_template: PromptTemplateWithMetadata, variables: InputVariables) -> str:
-        pass
-
-    @abstractmethod
-    def to_llm_syntax(self, messages: List[ChatMessage]) -> Union[str, List[ChatMessage]]:
-        raise NotImplementedError()
-
-    @abstractmethod
-    def call_service(
-            self,
-            formatted_prompt: str,
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> CompletionResponse:
-        pass
-
-    @abstractmethod
-    def call_service_stream(
-            self,
-            formatted_prompt: str,
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> Generator[CompletionChunk, None, None]:
-        pass
-
-    def get_model_params(self, llm_parameters: LLMParameters) -> LLMParameters:
-        return self._model_params_with_defaults.merge_and_override(llm_parameters)
-
-
-class ChatFlavor(Flavor, ABC):
-    @abstractmethod
-    def continue_chat(
-            self,
-            messages: List[ChatMessage],
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> ChatCompletionResponse:
-        pass
-
-    @abstractmethod
-    def continue_chat_stream(
-            self,
-            messages: List[ChatMessage],
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> Generator[CompletionChunk, None, None]:
-        pass
-
-
-class OpenAIChatFlavor(ChatFlavor, ABC):
-
-    @abstractmethod
-    def _call_openai(
-            self,
-            messages: List[ChatMessage],
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters,
-            stream: bool
-    ) -> Union[ChatCompletion, openai.Stream[ChatCompletionChunk]]:
-        pass
-
-    def format(self, prompt_template: PromptTemplateWithMetadata, variables: InputVariables) -> str:
-        # Extract messages JSON to enable formatting of individual content fields of each message. If we do not
-        # extract the JSON, current variable interpolation will fail on JSON curly braces.
-        messages_as_json: List[Dict[str, str]] = json.loads(prompt_template.content)
-        formatted_messages = [
-            {
-                "content": bind_template_variables(message['content'], variables), "role": message['role']
-            } for message in messages_as_json]
-        return json.dumps(formatted_messages)
-
-    def to_llm_syntax(self, messages: List[ChatMessage]) -> List[ChatMessage]:
-        return messages
-
-    def call_service(
-            self,
-            formatted_prompt: str,
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> CompletionResponse:
-        messages = json.loads(formatted_prompt)
-        completion = cast(ChatCompletion, self._call_openai(messages, provider_config, llm_parameters, stream=False))
-
-        return CompletionResponse(
-            content=completion.choices[0].message.content or '',
-            is_complete=completion.choices[0].finish_reason == 'stop',
-            openai_function_call=self.__maybe_function_call(completion),
-        )
-
-    # noinspection PyMethodMayBeStatic
-    def __maybe_function_call(self, completion: ChatCompletion) -> Optional[OpenAIFunctionCall]:
-        maybe_function_call = completion.choices[0].message.function_call
-        if maybe_function_call:
-            return OpenAIFunctionCall(
-                name=maybe_function_call.name,
-                arguments=maybe_function_call.arguments
-            )
-        return None
-
-    def call_service_stream(
-            self,
-            formatted_prompt: str,
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> Generator[CompletionChunk, None, None]:
-        messages = json.loads(formatted_prompt)
-        completion_stream = cast(Stream[ChatCompletionChunk],
-                                 self._call_openai(messages, provider_config, llm_parameters, stream=True))
-        for chunk in completion_stream:
-            yield CompletionChunk(
-                text=chunk.choices[0].delta.content or '',
-                is_complete=chunk.choices[0].finish_reason == 'stop',
-                openai_function_call=chunk.choices[0].delta.function_call
-            )
-
-    def continue_chat(
-            self,
-            messages: List[ChatMessage],
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> ChatCompletionResponse:
-        completion = cast(ChatCompletion, self._call_openai(messages, provider_config, llm_parameters, stream=False))
-
-        message_history = copy(messages)
-        message = completion.choices[0].message
-        message_history.append(ChatMessage(
-            role=message.role or '',
-            content=message.content or ''
-        ))
-        return ChatCompletionResponse(
-            content=message.content or '',
-            message_history=message_history,
-            is_complete=completion.choices[0].finish_reason == "stop"
-        )
-
-    def continue_chat_stream(
-            self,
-            messages: List[ChatMessage],
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> Generator[CompletionChunk, None, None]:
-        completion_stream = cast(Stream[ChatCompletionChunk],
-                                 self._call_openai(messages, provider_config, llm_parameters, stream=True))
-        for chunk in completion_stream:
-            yield CompletionChunk(
-                text=chunk.choices[0].delta.content or '',
-                is_complete=chunk.choices[0].finish_reason == "stop"
-            )
-
-
-class OpenAIChat(OpenAIChatFlavor):
-    record_format_type = "openai_chat"
-    _model_params_with_defaults = LLMParameters({
-        "model": "gpt-3.5-turbo"
-    })
-
-    def __init__(self) -> None:
-        self.client: Optional[openai.OpenAI] = None
-
-    @property
-    def provider(self) -> str:
-        return "openai"
-
-    def get_openai_client(self, openai_config: Optional[OpenAIConfig]) -> openai.OpenAI:
-        if self.client:
-            return self.client
-
-        if not openai_config:
-            raise FreeplayConfigurationError(
-                "Missing OpenAI key. Use a ProviderConfig to specify keys prior to getting completion.")
-
-        self.client = openai.OpenAI(api_key=openai_config.api_key, base_url=openai_config.base_url)
-        return self.client
-
-    def _call_openai(
-            self,
-            messages: List[ChatMessage],
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters,
-            stream: bool
-    ) -> Union[ChatCompletion, openai.Stream[ChatCompletionChunk]]:
-        client = self.get_openai_client(provider_config.openai)
-        try:
-            return client.chat.completions.create(
-                messages=cast(List[ChatCompletionMessageParam], messages),
-                **self.get_model_params(llm_parameters),
-                stream=stream,
-            )
-        except (BadRequestError, AuthenticationError) as e:
-            raise LLMClientError("Unable to call OpenAI") from e
-        except Exception as e:
-            raise LLMServerError("Unable to call OpenAI") from e
-
-
-class AzureOpenAIChat(OpenAIChatFlavor):
-    record_format_type = "azure_openai_chat"
-
-    def __init__(self) -> None:
-        self.client: Optional[openai.AzureOpenAI] = None
-
-    @property
-    def provider(self) -> str:
-        return "azure"
-
-    def get_azure_client(
-            self,
-            azure_config: Optional[AzureConfig],
-            api_version: Optional[str] = None,
-            endpoint: Optional[str] = None,
-            deployment: Optional[str] = None,
-    ) -> openai.AzureOpenAI:
-        if self.client:
-            return self.client
-
-        if not azure_config:
-            raise FreeplayConfigurationError(
-                "Missing Azure key. Use a ProviderConfig to specify keys prior to getting completion.")
-
-        self.client = openai.AzureOpenAI(
-            api_key=azure_config.api_key,
-            api_version=api_version,
-            azure_endpoint=endpoint or '',
-            azure_deployment=deployment,
-        )
-        return self.client
-
-    def _call_openai(
-            self,
-            messages: List[ChatMessage],
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters,
-            stream: bool
-    ) -> Any:
-        api_version = llm_parameters.get('api_version')
-        deployment_id = llm_parameters.get('deployment_id')
-        resource_name = llm_parameters.get('resource_name')
-        endpoint = f'https://{resource_name}.openai.azure.com'
-        llm_parameters.pop('resource_name')
-
-        client = self.get_azure_client(
-            azure_config=provider_config.azure,
-            api_version=api_version,
-            endpoint=endpoint,
-            deployment=deployment_id,
-        )
-
-        try:
-            return client.chat.completions.create(
-                messages=cast(List[ChatCompletionMessageParam], messages),
-                **self.get_model_params(llm_parameters),
-                stream=stream,
-            )
-        except (BadRequestError, AuthenticationError) as e:
-            raise LLMClientError("Unable to call Azure") from e
-        except Exception as e:
-            raise LLMServerError("Unable to call Azure") from e
-
-
-class AnthropicClaudeChat(ChatFlavor):
-    record_format_type = "anthropic_chat"
-    _model_params_with_defaults = LLMParameters({
-        "model": "claude-2",
-        "max_tokens_to_sample": 100
-    })
-
-    def __init__(self) -> None:
-        self.client: Optional[anthropic.Anthropic] = None
-
-    @property
-    def provider(self) -> str:
-        return "anthropic"
-
-    def get_anthropic_client(self, anthropic_config: Optional[AnthropicConfig]) -> anthropic.Client:
-        if self.client:
-            return self.client
-
-        if not anthropic_config:
-            raise FreeplayConfigurationError(
-                "Missing Anthropic key. Use a ProviderConfig to specify keys prior to getting completion.")
-
-        self.client = anthropic.Client(api_key=anthropic_config.api_key)
-        return self.client
-
-    # This just formats the prompt for uploading to the record endpoint.
-    # TODO: Move this to a base class.
-    def format(self, prompt_template: PromptTemplateWithMetadata, variables: InputVariables) -> str:
-        # Extract messages JSON to enable formatting of individual content fields of each message. If we do not
-        # extract the JSON, current variable interpolation will fail on JSON curly braces.
-        messages_as_json: List[Dict[str, str]] = json.loads(prompt_template.content)
-        formatted_messages = [
-            {
-                "content": bind_template_variables(message['content'], variables),
-                "role": self.__to_anthropic_role(message['role'])
-            } for message in messages_as_json]
-        return json.dumps(formatted_messages)
-
-    def to_llm_syntax(self, messages: List[ChatMessage]) -> str:
-        formatted_messages = [
-            ChatMessage(
-                content=message['content'],
-                role=self.__to_anthropic_role(message['role'])
-            ) for message in messages
-        ]
-        return self.__to_anthropic_chat_format(formatted_messages)
-
-    @staticmethod
-    def __to_anthropic_role(role: str) -> str:
-        if role == 'Human':
-            return 'Human'
-        elif role == 'assistant' or role == 'Assistant':
-            return 'Assistant'
-        else:
-            # Anthropic does not support system role for now.
-            return 'Human'
-
-    @staticmethod
-    def __to_anthropic_chat_format(messages: List[ChatMessage]) -> str:
-        formatted_messages = []
-        for message in messages:
-            formatted_messages.append(f"{message['role']}: {message['content']}")
-        formatted_messages.append('Assistant:')
-
-        return "\n\n" + "\n\n".join(formatted_messages)
-
-    def continue_chat(
-            self,
-            messages: List[ChatMessage],
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> ChatCompletionResponse:
-        formatted_prompt = self.__to_anthropic_chat_format(messages)
-        try:
-            client = self.get_anthropic_client(provider_config.anthropic)
-            completion = client.completions.create(
-                prompt=formatted_prompt,
-                **self.get_model_params(llm_parameters)
-            )
-            content = completion.completion
-            message_history = messages + [{"role": "assistant", "content": content}]
-            return ChatCompletionResponse(
-                content=content,
-                is_complete=completion.stop_reason == 'stop_sequence',
-                message_history=message_history,
-            )
-        except anthropic.APIError as e:
-            raise FreeplayError("Error calling Anthropic") from e
-
-    def continue_chat_stream(
-            self,
-            messages: List[ChatMessage],
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> Generator[CompletionChunk, None, None]:
-        formatted_prompt = self.__to_anthropic_chat_format(messages)
-        try:
-            client = self.get_anthropic_client(provider_config.anthropic)
-            anthropic_response = client.completions.create(
-                prompt=formatted_prompt,
-                stream=True,
-                **self.get_model_params(llm_parameters)
-            )
-
-            for chunk in anthropic_response:
-                yield CompletionChunk(
-                    text=chunk.completion,
-                    is_complete=chunk.stop_reason == 'stop_sequence'
-                )
-        except anthropic.APIError as e:
-            raise FreeplayError("Error calling Anthropic") from e
-
-    def call_service(self, formatted_prompt: str, provider_config: ProviderConfig,
-                     llm_parameters: LLMParameters) -> CompletionResponse:
-        messages = json.loads(formatted_prompt)
-        completion = self.continue_chat(messages, provider_config, llm_parameters)
-        return CompletionResponse(
-            content=completion.content,
-            is_complete=completion.is_complete,
-        )
-
-    def call_service_stream(
-            self,
-            formatted_prompt: str,
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> Generator[CompletionChunk, None, None]:
-        messages = json.loads(formatted_prompt)
-        return self.continue_chat_stream(messages, provider_config, llm_parameters)
-
-
-def pick_flavor_from_config(completion_flavor: Optional[Flavor], ui_flavor_name: Optional[str]) -> Flavor:
-    ui_flavor = Flavor.get_by_name(ui_flavor_name) if ui_flavor_name else None
-    flavor = completion_flavor or ui_flavor
-
-    if flavor is None:
-        raise FreeplayConfigurationError(
-            "Flavor must be configured on either the Freeplay client, completion call, "
-            "or in the Freeplay UI. Unable to fulfill request.")
-
-    return flavor
-
-
-def get_chat_flavor_from_config(completion_flavor: Optional[Flavor], ui_flavor_name: Optional[str]) -> ChatFlavor:
-    flavor = pick_flavor_from_config(completion_flavor, ui_flavor_name)
-    return require_chat_flavor(flavor)
-
-
-def require_chat_flavor(flavor: Flavor) -> ChatFlavor:
-    if not isinstance(flavor, ChatFlavor):
-        raise FreeplayConfigurationError('A Chat flavor is required to start a chat session.')
-
-    return flavor

freeplay/provider_config.py

@@ -1,49 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-
-from .errors import FreeplayConfigurationError
-
-
-@dataclass
-class OpenAIConfig:
-    api_key: str
-    base_url: Optional[str] = None
-
-    def validate(self) -> None:
-        if not self.api_key or not self.api_key.strip():
-            raise FreeplayConfigurationError("OpenAI API key not set. It must be set to make calls to the service.")
-
-
-@dataclass
-class AzureConfig(OpenAIConfig):
-    engine: Optional[str] = None
-    api_version: Optional[str] = None
-
-    def validate(self) -> None:
-        super().validate()
-
-        if self.api_version is None:
-            raise FreeplayConfigurationError(
-                "OpenAI API version not set. It must be set to make calls to the service.")
-
-        if self.engine is None:
-            raise FreeplayConfigurationError("Azure engine is not set. It must be set to make calls to the service.")
-
-
-@dataclass
-class AnthropicConfig:
-    api_key: str
-
-
-@dataclass
-class ProviderConfig:
-    anthropic: Optional[AnthropicConfig] = None
-    openai: Optional[OpenAIConfig] = None
-    azure: Optional[AzureConfig] = None
-
-    def validate(self) -> None:
-        if all(config is None for config in [self.anthropic, self.openai, self.azure]):
-            FreeplayConfigurationError("At least one provider key must be set in ProviderConfig.")
-
-        if self.openai is not None:
-            self.openai.validate()