diff --git a/src/ProviderImplementations/OpenAi/OpenAiModelMetadataDirectory.php b/src/ProviderImplementations/OpenAi/OpenAiModelMetadataDirectory.php
new file mode 100644
index 0000000..68390da
--- /dev/null
+++ b/src/ProviderImplementations/OpenAi/OpenAiModelMetadataDirectory.php
@@ -0,0 +1,182 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\ProviderImplementations\OpenAi;
+
+use RuntimeException;
+use WordPress\AiClient\Files\Enums\FileTypeEnum;
+use WordPress\AiClient\Messages\Enums\ModalityEnum;
+use WordPress\AiClient\Providers\AbstractOpenAiCompatibleModelMetadataDirectory;
+use WordPress\AiClient\Providers\Models\DTO\ModelConfig;
+use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
+use WordPress\AiClient\Providers\Models\DTO\SupportedOption;
+use WordPress\AiClient\Providers\Models\Enums\CapabilityEnum;
+
+/**
+ * Class for the OpenAI model metadata directory.
+ *
+ * @since n.e.x.t
+ */
+class OpenAiModelMetadataDirectory extends AbstractOpenAiCompatibleModelMetadataDirectory
+{
+    /**
+     * @inheritDoc
+     */
+    protected function createRequest(string $path): RequestInterface
+    {
+        // Something like this.
+        return new OpenAiCompatibleRequest('https://api.openai.com/v1', $path);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected function parseResponseToModelMetadataList(ResponseInterface $response): array
+    {
+        $responseData = $response->getData();
+        if (!isset($responseData['data']) || !$responseData['data']) {
+            throw new RuntimeException(
+                'Unexpected API response: Missing the data key.'
+            );
+        }
+
+        // Unfortunately, the OpenAI API does not return model capabilities, so we have to hardcode them here.
+        $gptCapabilities = [
+            CapabilityEnum::textGeneration(),
+            CapabilityEnum::chatHistory(),
+        ];
+        $gptOptions = [
+            new SupportedOption(ModelConfig::KEY_SYSTEM_INSTRUCTION),
+            new SupportedOption(ModelConfig::KEY_CANDIDATE_COUNT),
+            new SupportedOption(ModelConfig::KEY_MAX_TOKENS),
+            new SupportedOption(ModelConfig::KEY_TEMPERATURE),
+            new SupportedOption(ModelConfig::KEY_TOP_P),
+            new SupportedOption(ModelConfig::KEY_STOP_SEQUENCES),
+            new SupportedOption(ModelConfig::KEY_PRESENCE_PENALTY),
+            new SupportedOption(ModelConfig::KEY_FREQUENCY_PENALTY),
+            new SupportedOption(ModelConfig::KEY_LOGPROBS),
+            new SupportedOption(ModelConfig::KEY_TOP_LOGPROBS),
+            new SupportedOption(ModelConfig::KEY_OUTPUT_MIME_TYPE, ['text/plain', 'application/json']),
+            new SupportedOption(ModelConfig::KEY_OUTPUT_SCHEMA),
+            // TODO: Where to put this as a constant?
+            new SupportedOption('functionCalling'),
+        ];
+        $gptMultimodalInputOptions = $gptOptions + [
+            new SupportedOption(
+                // TODO: Where to put this as a constant?
+                'inputModalities',
+                [
+                    [ModalityEnum::text()],
+                    [ModalityEnum::text(), ModalityEnum::image()],
+                    [ModalityEnum::text(), ModalityEnum::image(), ModalityEnum::audio()],
+                ]
+            ),
+        ];
+        $gptMultimodalSpeechOutputOptions = $gptMultimodalInputOptions + [
+            new SupportedOption(
+                ModelConfig::KEY_OUTPUT_MODALITIES,
+                [
+                    [ModalityEnum::text()],
+                    [ModalityEnum::text(), ModalityEnum::audio()],
+                ]
+            ),
+        ];
+        $imageCapabilities = [
+            CapabilityEnum::imageGeneration(),
+        ];
+        $dalleImageOptions = [
+            new SupportedOption(ModelConfig::KEY_CANDIDATE_COUNT),
+            new SupportedOption(ModelConfig::KEY_OUTPUT_MIME_TYPE, ['image/png']),
+            // TODO: Where to put this as a constant?
+            new SupportedOption('outputFileType', [FileTypeEnum::inline(), FileTypeEnum::remote()]),
+            // TODO: Where to put this as a constant?
+            new SupportedOption('imageOrientation', ['square', 'landscape', 'portrait']),
+            // TODO: Where to put this as a constant?
+            new SupportedOption('imageAspectRatio', ['1:1', '7:4', '4:7']),
+        ];
+        $gptImageOptions = [
+            new SupportedOption(ModelConfig::KEY_CANDIDATE_COUNT),
+            new SupportedOption(ModelConfig::KEY_OUTPUT_MIME_TYPE, ['image/png', 'image/jpeg', 'image/webp']),
+            // TODO: Where to put this as a constant?
+            new SupportedOption('outputFileType', [FileTypeEnum::inline()]),
+            // TODO: Where to put this as a constant?
+            new SupportedOption('imageOrientation', ['square', 'landscape', 'portrait']),
+            // TODO: Where to put this as a constant?
+            new SupportedOption('imageAspectRatio', ['1:1', '3:2', '2:3']),
+        ];
+        $ttsCapabilities = [
+            CapabilityEnum::textToSpeechConversion(),
+        ];
+        $ttsOptions = [
+            new SupportedOption(ModelConfig::KEY_OUTPUT_MIME_TYPE, ['audio/mpeg', 'audio/ogg', 'audio/wav']),
+            // TODO: Where to put this as a constant?
+            new SupportedOption('voice'),
+        ];
+
+        return array_values(
+            array_map(
+                static function (array $modelData) use (
+                    $gptCapabilities,
+                    $gptOptions,
+                    $gptMultimodalInputOptions,
+                    $gptMultimodalSpeechOutputOptions,
+                    $imageCapabilities,
+                    $dalleImageOptions,
+                    $gptImageOptions,
+                    $ttsCapabilities,
+                    $ttsOptions,
+                ): ModelMetadata {
+                    $modelId = $modelData['id'];
+                    if (
+                        str_starts_with($modelId, 'dall-e-') ||
+                        str_starts_with($modelId, 'gpt-image-')
+                    ) {
+                        $modelCaps = $imageCapabilities;
+                        if (str_starts_with($modelId, 'gpt-image-')) {
+                            $modelOptions = $gptImageOptions;
+                        } else {
+                            $modelOptions = $dalleImageOptions;
+                        }
+                    } elseif (
+                        str_starts_with($modelId, 'tts-') ||
+                        str_contains($modelId, '-tts')
+                    ) {
+                        $modelCaps = $ttsCapabilities;
+                        $modelOptions = $ttsOptions;
+                    } elseif (
+                        (str_starts_with($modelId, 'gpt-') || str_starts_with($modelId, 'o1-'))
+                        && !str_contains($modelId, '-instruct')
+                        && !str_contains($modelId, '-realtime')
+                    ) {
+                        if (str_starts_with($modelId, 'gpt-4o')) {
+                            $modelCaps = $gptCapabilities;
+                            $modelOptions = $gptMultimodalInputOptions;
+                            // New multimodal output model for audio generation.
+                            if (str_contains($modelId, '-audio')) {
+                                $modelOptions = $gptMultimodalSpeechOutputOptions;
+                            }
+                        } elseif (!str_contains($modelId, '-audio')) {
+                            $modelCaps = $gptCapabilities;
+                            $modelOptions = $gptOptions;
+                        } else {
+                            $modelCaps = [];
+                            $modelOptions = [];
+                        }
+                    } else {
+                        $modelCaps = [];
+                        $modelOptions = [];
+                    }
+
+                    return new ModelMetadata(
+                        $modelId,
+                        $modelId, // The OpenAI API does not return a display name.
+                        $modelCaps,
+                        $modelOptions
+                    );
+                },
+                (array) $responseData['data']
+            )
+        );
+    }
+}
diff --git a/src/ProviderImplementations/OpenAi/OpenAiProvider.php b/src/ProviderImplementations/OpenAi/OpenAiProvider.php
new file mode 100644
index 0000000..cba2c73
--- /dev/null
+++ b/src/ProviderImplementations/OpenAi/OpenAiProvider.php
@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\ProviderImplementations\OpenAi;
+
+use RuntimeException;
+use WordPress\AiClient\Providers\AbstractProvider;
+use WordPress\AiClient\Providers\Contracts\ModelMetadataDirectoryInterface;
+use WordPress\AiClient\Providers\Contracts\ProviderAvailabilityInterface;
+use WordPress\AiClient\Providers\Contracts\ProviderInterface;
+use WordPress\AiClient\Providers\DTO\ProviderMetadata;
+use WordPress\AiClient\Providers\Enums\ProviderTypeEnum;
+use WordPress\AiClient\Providers\ListModelsApiBasedProviderAvailability;
+use WordPress\AiClient\Providers\Models\Contracts\ModelInterface;
+use WordPress\AiClient\Providers\Models\DTO\ModelConfig;
+use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
+
+/**
+ * Class for the OpenAI provider.
+ *
+ * @since n.e.x.t
+ */
+class OpenAiProvider extends AbstractProvider
+{
+    /**
+     * @inheritDoc
+     */
+    protected static function createModel(
+        ModelMetadata $modelMetadata,
+        ProviderMetadata $providerMetadata
+    ): ModelInterface {
+        $capabilities = $modelMetadata->getSupportedCapabilities();
+        foreach ($capabilities as $capability) {
+            if ($capability->isTextGeneration()) {
+                return new OpenAiTextGenerationModel($modelMetadata, $providerMetadata);
+            }
+            if ($capability->isImageGeneration()) {
+                // TODO: Implement OpenAiImageGenerationModel.
+                return new OpenAiImageGenerationModel($modelMetadata, $providerMetadata);
+            }
+            if ($capability->isTextToSpeechConversion()) {
+                // TODO: Implement OpenAiTextToSpeechConversionModel.
+                return new OpenAiTextToSpeechConversionModel($modelMetadata, $providerMetadata);
+            }
+        }
+
+        throw new RuntimeException(
+            'Unsupported model capabilities: ' . implode(', ', $capabilities)
+        );
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected static function createProviderMetadata(): ProviderMetadata
+    {
+        return new ProviderMetadata(
+            'openai',
+            'OpenAI',
+            ProviderTypeEnum::cloud()
+        );
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected static function createProviderAvailability(): ProviderAvailabilityInterface
+    {
+        // Check valid API access by attempting to list models.
+        return new ListModelsApiBasedProviderAvailability(
+            static::modelMetadataDirectory()
+        );
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected static function createModelMetadataDirectory(): ModelMetadataDirectoryInterface
+    {
+        return new OpenAiModelMetadataDirectory();
+    }
+}
diff --git a/src/ProviderImplementations/OpenAi/OpenAiTextGenerationModel.php b/src/ProviderImplementations/OpenAi/OpenAiTextGenerationModel.php
new file mode 100644
index 0000000..27d3db4
--- /dev/null
+++ b/src/ProviderImplementations/OpenAi/OpenAiTextGenerationModel.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\ProviderImplementations\OpenAi;
+
+use WordPress\AiClient\Providers\Models\AbstractOpenAiCompatibleTextGenerationModel;
+use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
+
+/**
+ * Class for an OpenAI text generation model.
+ *
+ * @since n.e.x.t
+ */
+class OpenAiTextGenerationModel extends AbstractOpenAiCompatibleTextGenerationModel
+{
+    /**
+     * @inheritDoc
+     */
+    protected function createRequest(string $path, array $params): RequestInterface
+    {
+        // Something like this.
+        return new OpenAiCompatibleRequest('https://api.openai.com/v1', $path);
+    }
+}
diff --git a/src/Providers/AbstractApiBasedModelMetadataDirectory.php b/src/Providers/AbstractApiBasedModelMetadataDirectory.php
new file mode 100644
index 0000000..5365c88
--- /dev/null
+++ b/src/Providers/AbstractApiBasedModelMetadataDirectory.php
@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Providers;
+
+use InvalidArgumentException;
+use WordPress\AiClient\Providers\Contracts\ModelMetadataDirectoryInterface;
+use WordPress\AiClient\Providers\Models\Contracts\WithHttpTransporterInterface;
+use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
+use WordPress\AiClient\Providers\Models\Traits\WithHttpTransporterTrait;
+
+/**
+ * Base class for an API-based model metadata directory for a provider.
+ *
+ * @since n.e.x.t
+ */
+abstract class AbstractApiBasedModelMetadataDirectory implements
+    ModelMetadataDirectoryInterface,
+    WithHttpTransporterInterface
+{
+    use WithHttpTransporterTrait;
+
+    /**
+     * @var ?array<string, ModelMetadata> Map of model ID to model metadata, effectively for caching.
+     */
+    private ?array $modelMetadataMap = null;
+
+    /**
+     * @inheritdoc
+     */
+    final public function listModelMetadata(): array
+    {
+        $modelsMetadata = $this->getModelMetadataMap();
+        return array_values($modelsMetadata);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    final public function hasModelMetadata(string $modelId): bool
+    {
+        try {
+            $this->getModelMetadata();
+        } catch (InvalidArgumentException $e) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    final public function getModelMetadata(string $modelId): ModelMetadata
+    {
+        $modelsMetadata = $this->getModelMetadataMap();
+        if (!isset($modelsMetadata[$modelId])) {
+            throw new InvalidArgumentException(
+                sprintf('No model with ID %s was found in the provider', $modelId)
+            );
+        }
+        return $modelsMetadata[$modelId];
+    }
+
+    /**
+     * Returns the map of model ID to model metadata for all models from the provider.
+     *
+     * @since n.e.x.t
+     *
+     * @return array<string, ModelMetadata> Map of model ID to model metadata.
+     */
+    private function getModelMetadataMap(): array
+    {
+        if ($this->modelMetadataMap === null) {
+            $this->modelMetadataMap = $this->sendListModelsRequest();
+        }
+        return $this->modelMetadataMap;
+    }
+
+    /**
+     * Sends the API request to list models from the provider and returns the map of model ID to model metadata.
+     *
+     * @since n.e.x.t
+     *
+     * @return array<string, ModelMetadata> Map of model ID to model metadata.
+     */
+    abstract protected function sendListModelsRequest(): array;
+}
diff --git a/src/Providers/AbstractOpenAiCompatibleModelMetadataDirectory.php b/src/Providers/AbstractOpenAiCompatibleModelMetadataDirectory.php
new file mode 100644
index 0000000..3417d6c
--- /dev/null
+++ b/src/Providers/AbstractOpenAiCompatibleModelMetadataDirectory.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Providers;
+
+use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
+
+/**
+ * Base class for a model metadata directory for an OpenAI compatible provider.
+ *
+ * @since n.e.x.t
+ */
+abstract class AbstractOpenAiCompatibleModelMetadataDirectory extends AbstractApiBasedModelMetadataDirectory
+{
+    /**
+     * @inheritdoc
+     */
+    protected function sendListModelsRequest(): array
+    {
+        $httpTransporter = $this->getHttpTransporter();
+
+        // Something like this.
+        $request = $this->createRequest('models');
+        $response = $httpTransporter->sendRequest($request);
+
+        $modelsMetadataList = $this->parseResponseToModelMetadataList($response);
+
+        // Parse list to map.
+        return array_reduce(
+            $modelsMetadataList,
+            static function (array $carry, ModelMetadata $metadata) {
+                $carry[$metadata->getId()] = $metadata;
+                return $carry;
+            },
+            []
+        );
+    }
+
+    /**
+     * Creates a request object for the provider's API.
+     *
+     * @since n.e.x.t
+     *
+     * @param string $path The API endpoint path, relative to the base URI.
+     * @return RequestInterface The request object.
+     */
+    abstract protected function createRequest(string $path): RequestInterface;
+
+    /**
+     * Parses the response from the API endpoint to list models into a list of model metadata objects.
+     *
+     * @since n.e.x.t
+     *
+     * @param ResponseInterface $response The response from the API endpoint to list models.
+     * @return list<ModelMetadata> List of model metadata objects.
+     */
+    abstract protected function parseResponseToModelMetadataList(ResponseInterface $response): array;
+}
diff --git a/src/Providers/AbstractProvider.php b/src/Providers/AbstractProvider.php
new file mode 100644
index 0000000..5d8e2ef
--- /dev/null
+++ b/src/Providers/AbstractProvider.php
@@ -0,0 +1,128 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Providers;
+
+use WordPress\AiClient\Providers\Contracts\ModelMetadataDirectoryInterface;
+use WordPress\AiClient\Providers\Contracts\ProviderAvailabilityInterface;
+use WordPress\AiClient\Providers\Contracts\ProviderInterface;
+use WordPress\AiClient\Providers\DTO\ProviderMetadata;
+use WordPress\AiClient\Providers\Models\Contracts\ModelInterface;
+use WordPress\AiClient\Providers\Models\DTO\ModelConfig;
+use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
+
+/**
+ * Base class for a provider.
+ *
+ * @since n.e.x.t
+ */
+abstract class AbstractProvider implements ProviderInterface
+{
+    /**
+     * @var array<string, ProviderMetadata> Cache for provider metadata per class.
+     */
+    private static array $metadataCache = [];
+
+    /**
+     * @var array<string, ProviderAvailabilityInterface> Cache for provider availability per class.
+     */
+    private static array $availabilityCache = [];
+
+    /**
+     * @var array<string, ModelMetadataDirectoryInterface> Cache for model metadata directory per class.
+     */
+    private static array $modelMetadataDirectoryCache = [];
+
+    /**
+     * @inheritdoc
+     */
+    final public static function metadata(): ProviderMetadata
+    {
+        $className = static::class;
+        if (!isset(self::$metadataCache[$className])) {
+            self::$metadataCache[$className] = static::createProviderMetadata();
+        }
+        return self::$metadataCache[$className];
+    }
+
+    /**
+     * @inheritdoc
+     */
+    final public static function model(string $modelId, ?ModelConfig $modelConfig = null): ModelInterface
+    {
+        $providerMetadata = static::metadata();
+        $modelMetadata = static::modelMetadataDirectory()->getModelMetadata($modelId);
+
+        $model = static::createModel($modelMetadata, $providerMetadata);
+        if ($modelConfig) {
+            $model->setConfig($modelConfig);
+        }
+        return $model;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    final public static function availability(): ProviderAvailabilityInterface
+    {
+        $className = static::class;
+        if (!isset(self::$availabilityCache[$className])) {
+            self::$availabilityCache[$className] = static::createProviderAvailability();
+        }
+        return self::$availabilityCache[$className];
+    }
+
+    /**
+     * @inheritdoc
+     */
+    final public static function modelMetadataDirectory(): ModelMetadataDirectoryInterface
+    {
+        $className = static::class;
+        if (!isset(self::$modelMetadataDirectoryCache[$className])) {
+            self::$modelMetadataDirectoryCache[$className] = static::createModelMetadataDirectory();
+        }
+        return self::$modelMetadataDirectoryCache[$className];
+    }
+
+    /**
+     * Creates a model instance based on the given model metadata and provider metadata.
+     *
+     * @since n.e.x.t
+     *
+     * @param ModelMetadata $modelMetadata The model metadata.
+     * @param ProviderMetadata $providerMetadata The provider metadata.
+     * @return ModelInterface The new model instance.
+     */
+    abstract protected static function createModel(
+        ModelMetadata $modelMetadata,
+        ProviderMetadata $providerMetadata
+    ): ModelInterface;
+
+    /**
+     * Creates the provider metadata instance.
+     *
+     * @since n.e.x.t
+     *
+     * @return ProviderMetadata The provider metadata.
+     */
+    abstract protected static function createProviderMetadata(): ProviderMetadata;
+
+    /**
+     * Creates the provider availability instance.
+     *
+     * @since n.e.x.t
+     *
+     * @return ProviderAvailabilityInterface The provider availability.
+     */
+    abstract protected static function createProviderAvailability(): ProviderAvailabilityInterface;
+
+    /**
+     * Creates the model metadata directory instance.
+     *
+     * @since n.e.x.t
+     *
+     * @return ModelMetadataDirectoryInterface The model metadata directory.
+     */
+    abstract protected static function createModelMetadataDirectory(): ModelMetadataDirectoryInterface;
+}
diff --git a/src/Providers/GenerateTextApiBasedProviderAvailability.php b/src/Providers/GenerateTextApiBasedProviderAvailability.php
new file mode 100644
index 0000000..5c2fe8f
--- /dev/null
+++ b/src/Providers/GenerateTextApiBasedProviderAvailability.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Providers;
+
+use Exception;
+use WordPress\AiClient\Messages\DTO\Message;
+use WordPress\AiClient\Messages\DTO\MessagePart;
+use WordPress\AiClient\Messages\Enums\MessageRoleEnum;
+use WordPress\AiClient\Providers\Contracts\ProviderAvailabilityInterface;
+use WordPress\AiClient\Providers\Models\Contracts\ModelInterface;
+use WordPress\AiClient\Providers\Models\DTO\ModelConfig;
+use WordPress\AiClient\Providers\Models\TextGeneration\Contracts\TextGenerationModelInterface;
+
+/**
+ * Class to check availability for an API-based provider via a test request to the endpoint to generate text.
+ *
+ * @since n.e.x.t
+ */
+class GenerateTextApiBasedProviderAvailability implements ProviderAvailabilityInterface
+{
+    /**
+     * @var ModelInterface&TextGenerationModelInterface The model to use for checking availability.
+     */
+    private ModelInterface $model;
+
+    /**
+     * Constructor.
+     *
+     * @since n.e.x.t
+     *
+     * @param ModelInterface $model The model to use for checking availability.
+     */
+    public function __construct(ModelInterface $model)
+    {
+        if (!($model instanceof TextGenerationModelInterface)) {
+            throw new Exception(
+                'The model class to check provider availability must implement TextGenerationModelInterface.'
+            );
+        }
+        $this->model = $model;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function isConfigured(): bool
+    {
+        // Set config to use as few resources as possible for the test.
+        $modelConfig = ModelConfig::fromArray([
+            ModelConfig::KEY_MAX_TOKENS => 1,
+        ]);
+        $this->model->setConfig($modelConfig);
+
+        try {
+            // Attempt to generate text to check if the provider is available.
+            $this->model->generateTextResult([
+                new Message(
+                    MessageRoleEnum::user(),
+                    [new MessagePart('a')]
+                ),
+            ]);
+            return true;
+        } catch (Exception $e) {
+            // If an exception occurs, the provider is not available.
+            return false;
+        }
+    }
+}
diff --git a/src/Providers/ListModelsApiBasedProviderAvailability.php b/src/Providers/ListModelsApiBasedProviderAvailability.php
new file mode 100644
index 0000000..491fa64
--- /dev/null
+++ b/src/Providers/ListModelsApiBasedProviderAvailability.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Providers;
+
+use Exception;
+use WordPress\AiClient\Providers\Contracts\ModelMetadataDirectoryInterface;
+use WordPress\AiClient\Providers\Contracts\ProviderAvailabilityInterface;
+
+/**
+ * Class to check availability for an API-based provider via a test request to the endpoint to list models.
+ *
+ * @since n.e.x.t
+ */
+class ListModelsApiBasedProviderAvailability implements ProviderAvailabilityInterface
+{
+    /**
+     * @var ModelMetadataDirectoryInterface The model metadata directory to use for checking availability.
+     */
+    private ModelMetadataDirectoryInterface $modelMetadataDirectory;
+
+    /**
+     * Constructor.
+     *
+     * @since n.e.x.t
+     *
+     * @param ModelMetadataDirectoryInterface $modelMetadataDirectory The model metadata directory to use for checking
+     *                                                                availability.
+     */
+    public function __construct(ModelMetadataDirectoryInterface $modelMetadataDirectory)
+    {
+        $this->modelMetadataDirectory = $modelMetadataDirectory;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function isConfigured(): bool
+    {
+        try {
+            // Attempt to list models to check if the provider is available.
+            $this->modelMetadataDirectory->listModelMetadata();
+            return true;
+        } catch (Exception $e) {
+            // If an exception occurs, the provider is not available.
+            return false;
+        }
+    }
+}
diff --git a/src/Providers/Models/AbstractApiBasedModel.php b/src/Providers/Models/AbstractApiBasedModel.php
new file mode 100644
index 0000000..f553019
--- /dev/null
+++ b/src/Providers/Models/AbstractApiBasedModel.php
@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Providers\Models;
+
+use InvalidArgumentException;
+use WordPress\AiClient\Providers\DTO\ProviderMetadata;
+use WordPress\AiClient\Providers\Models\Contracts\ModelInterface;
+use WordPress\AiClient\Providers\Models\Contracts\WithHttpTransporterInterface;
+use WordPress\AiClient\Providers\Models\DTO\ModelConfig;
+use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
+use WordPress\AiClient\Providers\Models\Traits\WithHttpTransporterTrait;
+
+/**
+ * Base class for an API-based model for a provider.
+ *
+ * While this class contains no abstract methods, it is still abstract to ensure that each model class can actually
+ * perform generative AI tasks by implementing the corresponding interfaces.
+ *
+ * @since n.e.x.t
+ */
+abstract class AbstractApiBasedModel implements
+    ModelInterface,
+    WithHttpTransporterInterface
+{
+    use WithHttpTransporterTrait;
+
+    /**
+     * @var ModelMetadata The metadata for the model.
+     */
+    private ModelMetadata $metadata;
+
+    /**
+     * @var ProviderMetadata The metadata for the model's provider.
+     */
+    private ProviderMetadata $providerMetadata;
+
+    /**
+     * @var ModelConfig The configuration for the model.
+     */
+    private ModelConfig $config;
+
+    /**
+     * Constructor.
+     *
+     * @since n.e.x.t
+     *
+     * @param ModelMetadata $metadata The metadata for the model.
+     * @param ProviderMetadata $providerMetadata The metadata for the model's provider.
+     */
+    public function __construct(ModelMetadata $metadata, ProviderMetadata $providerMetadata)
+    {
+        $this->metadata = $metadata;
+        $this->providerMetadata = $providerMetadata;
+        $this->config = ModelConfig::fromArray([]);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    final public function metadata(): ModelMetadata
+    {
+        return $this->metadata;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    final public function providerMetadata(): ProviderMetadata
+    {
+        return $this->providerMetadata;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    final public function setConfig(ModelConfig $config): void
+    {
+        $this->config = $config;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    final public function getConfig(): ModelConfig
+    {
+        return $this->config;
+    }
+}
diff --git a/src/Providers/Models/AbstractOpenAiCompatibleTextGenerationModel.php b/src/Providers/Models/AbstractOpenAiCompatibleTextGenerationModel.php
new file mode 100644
index 0000000..738b690
--- /dev/null
+++ b/src/Providers/Models/AbstractOpenAiCompatibleTextGenerationModel.php
@@ -0,0 +1,473 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Providers\Models;
+
+use Generator;
+use InvalidArgumentException;
+use RuntimeException;
+use WordPress\AiClient\Files\Enums\FileTypeEnum;
+use WordPress\AiClient\Messages\DTO\Message;
+use WordPress\AiClient\Messages\DTO\MessagePart;
+use WordPress\AiClient\Messages\DTO\SystemMessage;
+use WordPress\AiClient\Messages\Enums\MessageRoleEnum;
+use WordPress\AiClient\Messages\Enums\ModalityEnum;
+use WordPress\AiClient\Providers\Models\TextGeneration\Contracts\TextGenerationModelInterface;
+use WordPress\AiClient\Results\DTO\Candidate;
+use WordPress\AiClient\Results\DTO\GenerativeAiResult;
+use WordPress\AiClient\Results\DTO\TokenUsage;
+use WordPress\AiClient\Results\Enums\FinishReasonEnum;
+
+/**
+ * Base class for a text generation model for an OpenAI compatible provider.
+ *
+ * @since n.e.x.t
+ */
+abstract class AbstractOpenAiCompatibleTextGenerationModel extends AbstractApiBasedModel implements
+    TextGenerationModelInterface
+{
+    /**
+     * @inheritDoc
+     */
+    final public function generateTextResult(array $prompt): GenerativeAiResult
+    {
+        $httpTransporter = $this->getHttpTransporter();
+
+        $params = $this->prepareGenerateTextParams($prompt);
+
+        // Something like this.
+        $request = $this->createRequest('chat/completions', $params);
+        $response = $httpTransporter->sendRequest($request);
+
+        return $this->parseResponseToGenerativeAiResult($response);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    final public function streamGenerateTextResult(array $prompt): Generator
+    {
+        $params = $this->prepareGenerateTextParams($prompt);
+
+        // TODO: Implement streaming support.
+        throw new RuntimeException(
+            'Streaming is not yet implemented.'
+        );
+    }
+
+    /**
+     * Prepares the given prompt and the model configuration into parameters for the API request.
+     *
+     * @since n.e.x.t
+     *
+     * @param list<Message> $prompt The prompt to generate text for. Either a single message or a list of messages
+     *                              from a chat.
+     * @return array<string, mixed> The parameters for the API request.
+     */
+    protected function prepareGenerateTextParams(array $prompt): array
+    {
+        $config = $this->getConfig();
+
+        $systemInstruction = $config->getSystemInstruction();
+        if ($systemInstruction) {
+            $prompt = $this->mergeSystemInstruction($prompt, $systemInstruction);
+        }
+
+        $params = [
+            'model' => $this->metadata()->getId(),
+            'messages' => $this->prepareMessagesParam($prompt),
+        ];
+
+        $outputModalities = $config->getOutputModalities();
+        if (is_array($outputModalities)) {
+            $this->validateOutputModalities($outputModalities);
+            if (count($outputModalities) > 1) {
+                $params['modalities'] = $this->prepareOutputModalitiesParam($outputModalities);
+            }
+        }
+
+        // TODO: Prepare other parameters based on config.
+
+        return $params;
+    }
+
+    /**
+     * Merges the system instruction into the prompt, ensuring that it is the first message.
+     *
+     * @since n.e.x.t
+     *
+     * @param list<Message> $prompt The prompt to merge the system instruction into.
+     * @param string $systemInstruction The system instruction to merge.
+     * @return list<Message> The updated prompt with the system instruction as the first message.
+     * @throws InvalidArgumentException If the first message in the prompt is already a system message.
+     */
+    protected function mergeSystemInstruction(array $prompt, string $systemInstruction): array
+    {
+        // If the first message is a system message, throw an exception due to a conflict.
+        if (isset($prompt[0]) && $prompt[0]->getRole() === MessageRoleEnum::system()) {
+            throw new InvalidArgumentException(
+                'The first message in the prompt cannot be a system message when using a system instruction.'
+            );
+        }
+
+        $systemMessage = new SystemMessage([
+            new MessagePart($systemInstruction),
+        ]);
+        array_unshift($prompt, $systemMessage);
+        return $prompt;
+    }
+
+    /**
+     * Prepares the messages parameter for the API request.
+     *
+     * @since n.e.x.t
+     *
+     * @param list<Message> $messages The messages to prepare.
+     * @return list<array<string, mixed>> The prepared messages parameter.
+     */
+    protected function prepareMessagesParam(array $messages): array
+    {
+        return array_map(
+            function (Message $message): array {
+                // Special case: Function response.
+                $messageParts = $message->getParts();
+                if (count($messageParts) === 1 && $messageParts[0]->getType()->isFunctionResponse()) {
+                    $functionResponse = $messageParts[0]->getFunctionResponse();
+                    if (!$functionResponse) {
+                        // This should be impossible due to class internals, but still needs to be checked.
+                        throw new RuntimeException(
+                            'The function response typed message part must contain a function response.'
+                        );
+                    }
+                    return [
+                        'role' => 'tool',
+                        'content' => json_encode($functionResponse->getResponse()),
+                        'tool_call_id' => $functionResponse->getId(),
+                    ];
+                }
+                return [
+                    'role' => $this->getMessageRoleString($message->getRole()),
+                    'content' => array_filter(array_map(
+                        function (MessagePart $part): ?array {
+                            return $this->getMessagePartContentData($part);
+                        },
+                        $messageParts
+                    )),
+                    'tool_calls' => array_filter(array_map(
+                        function (MessagePart $part): ?array {
+                            return $this->getMessagePartToolCallData($part);
+                        },
+                        $messageParts
+                    )),
+                ];
+            },
+            $messages
+        );
+    }
+
+    /**
+     * Returns the OpenAI API specific role string for the given message role.
+     *
+     * @since n.e.x.t
+     *
+     * @param MessageRoleEnum $role The message role.
+     * @return string The role for the API request.
+     */
+    protected function getMessageRoleString(MessageRoleEnum $role): string
+    {
+        if ($role === MessageRoleEnum::model()) {
+            return 'assistant';
+        }
+        if ($role === MessageRoleEnum::system()) {
+            return 'system';
+        }
+        return 'user';
+    }
+
+    /**
+     * Returns the OpenAI API specific content data for a message part.
+     *
+     * @since n.e.x.t
+     *
+     * @param MessagePart $part The message part to get the data for.
+     * @return ?array<string, mixed> The data for the message content part, or null if not applicable.
+     * @throws InvalidArgumentException If the message part type or data is unsupported.
+     */
+    protected function getMessagePartContentData(MessagePart $part): ?array
+    {
+        $type = $part->getType();
+        if ($type->isText()) {
+            return [
+                'type' => 'text',
+                'text' => $part->getText(),
+            ];
+        }
+        if ($type->isFile()) {
+            $file = $part->getFile();
+            if (!$file) {
+                // This should be impossible due to class internals, but still needs to be checked.
+                throw new RuntimeException(
+                    'The file typed message part must contain a file.'
+                );
+            }
+            if ($file->getFileType()->isRemote()) {
+                if ($file->isImage()) {
+                    return [
+                        'type' => 'image_url',
+                        'image_url' => [
+                            'url' => $file->getUrl(),
+                        ],
+                    ];
+                }
+                throw new InvalidArgumentException(
+                    sprintf(
+                        'Unsupported MIME type "%s" for remote file message part.',
+                        $file->getMimeType()
+                    )
+                );
+            }
+            // Else, it is an inline file.
+            if ($file->isImage()) {
+                return [
+                    'type' => 'image_url',
+                    'image_url' => [
+                        'url' => $file->getBase64Data(),
+                    ],
+                ];
+            }
+            if ($file->isAudio()) {
+                return [
+                    'type' => 'input_audio',
+                    'input_audio' => [
+                        'data' => $file->getBase64Data(),
+                        'format' => '', // TODO: Add method to transform MIME type into file extension.
+                    ],
+                ];
+            }
+            throw new InvalidArgumentException(
+                sprintf(
+                    'Unsupported MIME type "%s" for inline file message part.',
+                    $file->getMimeType()
+                )
+            );
+        }
+        if ($type->isFunctionCall()) {
+            // Skip, as this is separately included. See `getMessagePartToolCallData()`.
+            return null;
+        }
+        if ($type->isFunctionResponse()) {
+            // Special case: Function response.
+            throw new InvalidArgumentException(
+                'The API only allows a single function response, as the only content of the message.'
+            );
+        }
+        throw new InvalidArgumentException(
+            sprintf(
+                'Unsupported message part type "%s".',
+                $type
+            )
+        );
+    }
+
+    /**
+     * Returns the OpenAI API specific tool calls data for a message part.
+     *
+     * @since n.e.x.t
+     *
+     * @param MessagePart $part The message part to get the data for.
+     * @return ?array<string, mixed> The data for the message tool call part, or null if not applicable.
+     * @throws InvalidArgumentException If the message part type or data is unsupported.
+     */
+    protected function getMessagePartToolCallData(MessagePart $part): ?array
+    {
+        $type = $part->getType();
+        if ($type->isFunctionCall()) {
+            $functionCall = $part->getFunctionCall();
+            if (!$functionCall) {
+                // This should be impossible due to class internals, but still needs to be checked.
+                throw new RuntimeException(
+                    'The function call typed message part must contain a function call.'
+                );
+            }
+            return [
+                'type' => 'function',
+                'id' => $functionCall->getId(),
+                'function' => [
+                    'name' => $functionCall->getName(),
+                    'arguments' => json_encode($functionCall->getArgs()),
+                ],
+            ];
+        }
+        // All other types are handled in `getMessagePartContentData()`.
+        return null;
+    }
+
+    /**
+     * Validates that the given output modalities to ensure that at least one output modality is text.
+     *
+     * @since n.e.x.t
+     *
+     * @param array<ModalityEnum> $outputModalities The output modalities to validate.
+     * @throws InvalidArgumentException If no text output modality is present.
+     */
+    protected function validateOutputModalities(array $outputModalities): void
+    {
+        // If no output modalities are set, it's fine, as we can assume text.
+        if (count($outputModalities) === 0) {
+            return;
+        }
+
+        foreach ($outputModalities as $modality) {
+            if ($modality->isText()) {
+                return;
+            }
+        }
+
+        throw new InvalidArgumentException(
+            'A text output modality must be present when generating text.'
+        );
+    }
+
+    /**
+     * Prepares the output modalities parameter for the API request.
+     *
+     * @since n.e.x.t
+     *
+     * @param array<ModalityEnum> $modalities The modalities to prepare.
+     * @return list<string> The prepared modalities parameter.
+     */
+    protected function prepareOutputModalitiesParam(array $modalities): array
+    {
+        $prepared = [];
+        foreach ($modalities as $modality) {
+            if ($modality->isText()) {
+                $prepared[] = 'text';
+            } elseif ($modality->isImage()) {
+                $prepared[] = 'image';
+            } elseif ($modality->isAudio()) {
+                $prepared[] = 'audio';
+            } else {
+                throw new InvalidArgumentException(
+                    sprintf(
+                        'Unsupported output modality "%s".',
+                        $modality
+                    )
+                );
+            }
+        }
+        return $prepared;
+    }
+
+    /**
+     * Creates a request object for the provider's API.
+     *
+     * @since n.e.x.t
+     *
+     * @param string $path The API endpoint path, relative to the base URI.
+     * @param array<string, mixed> $params The parameters for the API request.
+     * @return RequestInterface The request object.
+     */
+    abstract protected function createRequest(string $path, array $params): RequestInterface;
+
+    /**
+     * Parses the response from the API endpoint to a generative AI result.
+     *
+     * @since n.e.x.t
+     *
+     * @param ResponseInterface $response The response from the API endpoint.
+     * @return GenerativeAiResult The parsed generative AI result.
+     */
+    protected function parseResponseToGenerativeAiResult(ResponseInterface $response): GenerativeAiResult
+    {
+        $responseData = $response->getData();
+        if (!isset($responseData['choices']) || !$responseData['choices']) {
+            throw new RuntimeException(
+                'Unexpected API response: Missing the choices key.'
+            );
+        }
+        if (!is_array($responseData['choices'])) {
+            throw new RuntimeException(
+                'Unexpected API response: The choices key must contain an array.'
+            );
+        }
+
+        $candidates = [];
+        foreach ($responseData['choices'] as $choice) {
+            if (!is_array($choice)) {
+                throw new RuntimeException(
+                    'Unexpected API response: Each element in the choices key must be an associative array.'
+                );
+            }
+            $candidates[] = $this->parseResponseChoiceToCandidate($choice);
+        }
+
+        $id = $responseData['id'] ?? '';
+        $tokenUsage = new TokenUsage(
+            $responseData['usage']['prompt_tokens'] ?? 0,
+            $responseData['usage']['completion_tokens'] ?? 0,
+            $responseData['usage']['total_tokens'] ?? 0
+        );
+
+        // Use any other data from the response as provider metadata.
+        $providerMetadata = $responseData;
+        unset($providerMetadata['id'], $providerMetadata['choices'], $providerMetadata['usage']);
+
+        return new GenerativeAiResult(
+            $id,
+            $candidates,
+            $tokenUsage,
+            $providerMetadata
+        );
+    }
+
+    /**
+     * Parses a single choice from the API response into a Candidate object.
+     *
+     * @since n.e.x.t
+     *
+     * @param array<string, mixed> $choice The choice data from the API response.
+     * @return Candidate The parsed candidate.
+     * @throws RuntimeException If the choice data is invalid.
+     */
+    protected function parseResponseChoiceToCandidate(array $choice): Candidate
+    {
+        if (!isset($choice['message']) || !is_array($choice['message'])) {
+            throw new RuntimeException(
+                'Unexpected API response: Each choice must contain a message key with an associative array.'
+            );
+        }
+
+        // TODO: Correctly implement this, as this is not correct - 'message' isn't just a string.
+        $message = new Message($choice['message']);
+
+        if (!isset($choice['finish_reason']) || !is_string($choice['finish_reason'])) {
+            throw new RuntimeException(
+                'Unexpected API response: Each choice must contain a finish_reason key with a string value.'
+            );
+        }
+        switch ($choice['finish_reason']) {
+            case 'stop':
+                $finishReason = FinishReasonEnum::stop();
+                break;
+            case 'length':
+                $finishReason = FinishReasonEnum::length();
+                break;
+            case 'content_filter':
+                $finishReason = FinishReasonEnum::contentFilter();
+                break;
+            case 'tool_calls':
+                $finishReason = FinishReasonEnum::toolCalls();
+                break;
+            default:
+                throw new RuntimeException(
+                    sprintf(
+                        'Unexpected API response: Invalid finish reason "%s".',
+                        $choice['finish_reason']
+                    )
+                );
+        }
+
+        return new Candidate($message, $finishReason);
+    }
+}
diff --git a/src/Providers/Models/Contracts/ModelInterface.php b/src/Providers/Models/Contracts/ModelInterface.php
index e0448e0..1c6adbc 100644
--- a/src/Providers/Models/Contracts/ModelInterface.php
+++ b/src/Providers/Models/Contracts/ModelInterface.php
@@ -4,6 +4,7 @@
 
 namespace WordPress\AiClient\Providers\Models\Contracts;
 
+use WordPress\AiClient\Providers\DTO\ProviderMetadata;
 use WordPress\AiClient\Providers\Models\DTO\ModelConfig;
 use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
 
@@ -26,6 +27,15 @@ interface ModelInterface
      */
     public function metadata(): ModelMetadata;
 
+    /**
+     * Returns the metadata for the model's provider.
+     *
+     * @since n.e.x.t
+     *
+     * @return ProviderMetadata The provider metadata.
+     */
+    public function providerMetadata(): ProviderMetadata;
+
     /**
      * Sets model configuration.
      *
diff --git a/src/Providers/Models/Traits/WithHttpTransporterTrait.php b/src/Providers/Models/Traits/WithHttpTransporterTrait.php
new file mode 100644
index 0000000..251d754
--- /dev/null
+++ b/src/Providers/Models/Traits/WithHttpTransporterTrait.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Providers\Models\Traits;
+
+use RuntimeException;
+use WordPress\AiClient\Providers\Contracts\HttpTransporterInterface;
+
+/**
+ * Trait for a class that implements WithHttpTransporterInterface.
+ *
+ * @since n.e.x.t
+ */
+trait WithHttpTransporterTrait
+{
+    private ?HttpTransporterInterface $httpTransporter = null;
+
+    public function setHttpTransporter(HttpTransporterInterface $httpTransporter): void
+    {
+        $this->httpTransporter = $httpTransporter;
+    }
+
+    public function getHttpTransporter(): HttpTransporterInterface
+    {
+        if ($this->httpTransporter === null) {
+            throw new RuntimeException(
+                'HttpTransporterInterface instance not set. Make sure you use the AiClient class for all requests.'
+            );
+        }
+        return $this->httpTransporter;
+    }
+}