first commit

wp-includes/php-ai-client/third-party/Http/Discovery/ClassDiscovery.php

@@ -0,0 +1,219 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery;
+
+use WordPress\AiClientDependencies\Http\Discovery\Exception\ClassInstantiationFailedException;
+use WordPress\AiClientDependencies\Http\Discovery\Exception\DiscoveryFailedException;
+use WordPress\AiClientDependencies\Http\Discovery\Exception\NoCandidateFoundException;
+use WordPress\AiClientDependencies\Http\Discovery\Exception\StrategyUnavailableException;
+use WordPress\AiClientDependencies\Http\Discovery\Strategy\DiscoveryStrategy;
+/**
+ * Registry that based find results on class existence.
+ *
+ * @author David de Boer <david@ddeboer.nl>
+ * @author Márk Sági-Kazár <mark.sagikazar@gmail.com>
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+abstract class ClassDiscovery
+{
+    /**
+     * A list of strategies to find classes.
+     *
+     * @var DiscoveryStrategy[]
+     */
+    private static $strategies = [Strategy\GeneratedDiscoveryStrategy::class, Strategy\CommonClassesStrategy::class, Strategy\CommonPsr17ClassesStrategy::class, Strategy\PuliBetaStrategy::class];
+    private static $deprecatedStrategies = [Strategy\PuliBetaStrategy::class => \true];
+    /**
+     * Discovery cache to make the second time we use discovery faster.
+     *
+     * @var array
+     */
+    private static $cache = [];
+    /**
+     * Finds a class.
+     *
+     * @param string $type
+     *
+     * @return string|\Closure
+     *
+     * @throws DiscoveryFailedException
+     */
+    protected static function findOneByType($type)
+    {
+        // Look in the cache
+        if (null !== $class = self::getFromCache($type)) {
+            return $class;
+        }
+        static $skipStrategy;
+        $skipStrategy ?? $skipStrategy = self::safeClassExists(Strategy\GeneratedDiscoveryStrategy::class) ? \false : Strategy\GeneratedDiscoveryStrategy::class;
+        $exceptions = [];
+        foreach (self::$strategies as $strategy) {
+            if ($skipStrategy === $strategy) {
+                continue;
+            }
+            try {
+                $candidates = $strategy::getCandidates($type);
+            } catch (StrategyUnavailableException $e) {
+                if (!isset(self::$deprecatedStrategies[$strategy])) {
+                    $exceptions[] = $e;
+                }
+                continue;
+            }
+            foreach ($candidates as $candidate) {
+                if (isset($candidate['condition'])) {
+                    if (!self::evaluateCondition($candidate['condition'])) {
+                        continue;
+                    }
+                }
+                // save the result for later use
+                self::storeInCache($type, $candidate);
+                return $candidate['class'];
+            }
+            $exceptions[] = new NoCandidateFoundException($strategy, $candidates);
+        }
+        throw DiscoveryFailedException::create($exceptions);
+    }
+    /**
+     * Get a value from cache.
+     *
+     * @param string $type
+     *
+     * @return string|null
+     */
+    private static function getFromCache($type)
+    {
+        if (!isset(self::$cache[$type])) {
+            return;
+        }
+        $candidate = self::$cache[$type];
+        if (isset($candidate['condition'])) {
+            if (!self::evaluateCondition($candidate['condition'])) {
+                return;
+            }
+        }
+        return $candidate['class'];
+    }
+    /**
+     * Store a value in cache.
+     *
+     * @param string $type
+     * @param string $class
+     */
+    private static function storeInCache($type, $class)
+    {
+        self::$cache[$type] = $class;
+    }
+    /**
+     * Set new strategies and clear the cache.
+     *
+     * @param string[] $strategies list of fully qualified class names that implement DiscoveryStrategy
+     */
+    public static function setStrategies(array $strategies)
+    {
+        self::$strategies = $strategies;
+        self::clearCache();
+    }
+    /**
+     * Returns the currently configured discovery strategies as fully qualified class names.
+     *
+     * @return string[]
+     */
+    public static function getStrategies(): iterable
+    {
+        return self::$strategies;
+    }
+    /**
+     * Append a strategy at the end of the strategy queue.
+     *
+     * @param string $strategy Fully qualified class name of a DiscoveryStrategy
+     */
+    public static function appendStrategy($strategy)
+    {
+        self::$strategies[] = $strategy;
+        self::clearCache();
+    }
+    /**
+     * Prepend a strategy at the beginning of the strategy queue.
+     *
+     * @param string $strategy Fully qualified class name to a DiscoveryStrategy
+     */
+    public static function prependStrategy($strategy)
+    {
+        array_unshift(self::$strategies, $strategy);
+        self::clearCache();
+    }
+    public static function clearCache()
+    {
+        self::$cache = [];
+    }
+    /**
+     * Evaluates conditions to boolean.
+     *
+     * @return bool
+     */
+    protected static function evaluateCondition($condition)
+    {
+        if (is_string($condition)) {
+            // Should be extended for functions, extensions???
+            return self::safeClassExists($condition);
+        }
+        if (is_callable($condition)) {
+            return (bool) $condition();
+        }
+        if (is_bool($condition)) {
+            return $condition;
+        }
+        if (is_array($condition)) {
+            foreach ($condition as $c) {
+                if (\false === static::evaluateCondition($c)) {
+                    // Immediately stop execution if the condition is false
+                    return \false;
+                }
+            }
+            return \true;
+        }
+        return \false;
+    }
+    /**
+     * Get an instance of the $class.
+     *
+     * @param string|\Closure $class a FQCN of a class or a closure that instantiate the class
+     *
+     * @return object
+     *
+     * @throws ClassInstantiationFailedException
+     */
+    protected static function instantiateClass($class)
+    {
+        try {
+            if (is_string($class)) {
+                return new $class();
+            }
+            if (is_callable($class)) {
+                return $class();
+            }
+        } catch (\Exception $e) {
+            throw new ClassInstantiationFailedException('Unexpected exception when instantiating class.', 0, $e);
+        }
+        throw new ClassInstantiationFailedException('Could not instantiate class because parameter is neither a callable nor a string');
+    }
+    /**
+     * We need a "safe" version of PHP's "class_exists" because Magento has a bug
+     * (or they call it a "feature"). Magento is throwing an exception if you do class_exists()
+     * on a class that ends with "Factory" and if that file does not exits.
+     *
+     * This function catches all potential exceptions and makes sure to always return a boolean.
+     *
+     * @param string $class
+     *
+     * @return bool
+     */
+    public static function safeClassExists($class)
+    {
+        try {
+            return class_exists($class) || interface_exists($class);
+        } catch (\Exception $e) {
+            return \false;
+        }
+    }
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Exception.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery;
+
+/**
+ * An interface implemented by all discovery related exceptions.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+interface Exception extends \Throwable
+{
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Exception/ClassInstantiationFailedException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Exception;
+
+use WordPress\AiClientDependencies\Http\Discovery\Exception;
+/**
+ * Thrown when a class fails to instantiate.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+final class ClassInstantiationFailedException extends \RuntimeException implements Exception
+{
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Exception/DiscoveryFailedException.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Exception;
+
+use WordPress\AiClientDependencies\Http\Discovery\Exception;
+/**
+ * Thrown when all discovery strategies fails to find a resource.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+final class DiscoveryFailedException extends \Exception implements Exception
+{
+    /**
+     * @var \Exception[]
+     */
+    private $exceptions;
+    /**
+     * @param string       $message
+     * @param \Exception[] $exceptions
+     */
+    public function __construct($message, array $exceptions = [])
+    {
+        $this->exceptions = $exceptions;
+        parent::__construct($message);
+    }
+    /**
+     * @param \Exception[] $exceptions
+     */
+    public static function create($exceptions)
+    {
+        $message = 'Could not find resource using any discovery strategy. Find more information at http://docs.php-http.org/en/latest/discovery.html#common-errors';
+        foreach ($exceptions as $e) {
+            $message .= "\n - " . $e->getMessage();
+        }
+        $message .= "\n\n";
+        return new self($message, $exceptions);
+    }
+    /**
+     * @return \Exception[]
+     */
+    public function getExceptions()
+    {
+        return $this->exceptions;
+    }
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Exception/NoCandidateFoundException.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Exception;
+
+use WordPress\AiClientDependencies\Http\Discovery\Exception;
+/**
+ * When we have used a strategy but no candidates provided by that strategy could be used.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+final class NoCandidateFoundException extends \Exception implements Exception
+{
+    /**
+     * @param string $strategy
+     */
+    public function __construct($strategy, array $candidates)
+    {
+        $classes = array_map(function ($a) {
+            return $a['class'];
+        }, $candidates);
+        $message = sprintf('No valid candidate found using strategy "%s". We tested the following candidates: %s.', $strategy, implode(', ', array_map([$this, 'stringify'], $classes)));
+        parent::__construct($message);
+    }
+    private function stringify($mixed)
+    {
+        if (is_string($mixed)) {
+            return $mixed;
+        }
+        if (is_array($mixed) && 2 === count($mixed)) {
+            return sprintf('%s::%s', $this->stringify($mixed[0]), $mixed[1]);
+        }
+        return is_object($mixed) ? get_class($mixed) : gettype($mixed);
+    }
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Exception/NotFoundException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Exception;
+
+use WordPress\AiClientDependencies\Http\Discovery\Exception;
+/**
+ * Thrown when a discovery does not find any matches.
+ *
+ * @final do NOT extend this class, not final for BC reasons
+ *
+ * @author Márk Sági-Kazár <mark.sagikazar@gmail.com>
+ */
+/* final */
+class NotFoundException extends \RuntimeException implements Exception
+{
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Exception/PuliUnavailableException.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Exception;
+
+/**
+ * Thrown when we can't use Puli for discovery.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+final class PuliUnavailableException extends StrategyUnavailableException
+{
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Exception/StrategyUnavailableException.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Exception;
+
+use WordPress\AiClientDependencies\Http\Discovery\Exception;
+/**
+ * This exception is thrown when we cannot use a discovery strategy. This is *not* thrown when
+ * the discovery fails to find a class.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+class StrategyUnavailableException extends \RuntimeException implements Exception
+{
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Psr17FactoryDiscovery.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery;
+
+use WordPress\AiClientDependencies\Http\Discovery\Exception\DiscoveryFailedException;
+use WordPress\AiClientDependencies\Http\Discovery\Exception\NotFoundException as RealNotFoundException;
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ResponseFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ServerRequestFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UploadedFileFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UriFactoryInterface;
+/**
+ * Finds PSR-17 factories.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+final class Psr17FactoryDiscovery extends ClassDiscovery
+{
+    private static function createException($type, Exception $e)
+    {
+        return new RealNotFoundException('No PSR-17 ' . $type . ' found. Install a package from this list: https://packagist.org/providers/psr/http-factory-implementation', 0, $e);
+    }
+    /**
+     * @return RequestFactoryInterface
+     *
+     * @throws RealNotFoundException
+     */
+    public static function findRequestFactory()
+    {
+        try {
+            $messageFactory = static::findOneByType(RequestFactoryInterface::class);
+        } catch (DiscoveryFailedException $e) {
+            throw self::createException('request factory', $e);
+        }
+        return static::instantiateClass($messageFactory);
+    }
+    /**
+     * @return ResponseFactoryInterface
+     *
+     * @throws RealNotFoundException
+     */
+    public static function findResponseFactory()
+    {
+        try {
+            $messageFactory = static::findOneByType(ResponseFactoryInterface::class);
+        } catch (DiscoveryFailedException $e) {
+            throw self::createException('response factory', $e);
+        }
+        return static::instantiateClass($messageFactory);
+    }
+    /**
+     * @return ServerRequestFactoryInterface
+     *
+     * @throws RealNotFoundException
+     */
+    public static function findServerRequestFactory()
+    {
+        try {
+            $messageFactory = static::findOneByType(ServerRequestFactoryInterface::class);
+        } catch (DiscoveryFailedException $e) {
+            throw self::createException('server request factory', $e);
+        }
+        return static::instantiateClass($messageFactory);
+    }
+    /**
+     * @return StreamFactoryInterface
+     *
+     * @throws RealNotFoundException
+     */
+    public static function findStreamFactory()
+    {
+        try {
+            $messageFactory = static::findOneByType(StreamFactoryInterface::class);
+        } catch (DiscoveryFailedException $e) {
+            throw self::createException('stream factory', $e);
+        }
+        return static::instantiateClass($messageFactory);
+    }
+    /**
+     * @return UploadedFileFactoryInterface
+     *
+     * @throws RealNotFoundException
+     */
+    public static function findUploadedFileFactory()
+    {
+        try {
+            $messageFactory = static::findOneByType(UploadedFileFactoryInterface::class);
+        } catch (DiscoveryFailedException $e) {
+            throw self::createException('uploaded file factory', $e);
+        }
+        return static::instantiateClass($messageFactory);
+    }
+    /**
+     * @return UriFactoryInterface
+     *
+     * @throws RealNotFoundException
+     */
+    public static function findUriFactory()
+    {
+        try {
+            $messageFactory = static::findOneByType(UriFactoryInterface::class);
+        } catch (DiscoveryFailedException $e) {
+            throw self::createException('url factory', $e);
+        }
+        return static::instantiateClass($messageFactory);
+    }
+    /**
+     * @return UriFactoryInterface
+     *
+     * @throws RealNotFoundException
+     *
+     * @deprecated This will be removed in 2.0. Consider using the findUriFactory() method.
+     */
+    public static function findUrlFactory()
+    {
+        return static::findUriFactory();
+    }
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Psr18ClientDiscovery.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery;
+
+use WordPress\AiClientDependencies\Http\Discovery\Exception\DiscoveryFailedException;
+use WordPress\AiClientDependencies\Http\Discovery\Exception\NotFoundException as RealNotFoundException;
+use WordPress\AiClientDependencies\Psr\Http\Client\ClientInterface;
+/**
+ * Finds a PSR-18 HTTP Client.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+final class Psr18ClientDiscovery extends ClassDiscovery
+{
+    /**
+     * Finds a PSR-18 HTTP Client.
+     *
+     * @return ClientInterface
+     *
+     * @throws RealNotFoundException
+     */
+    public static function find()
+    {
+        try {
+            $client = static::findOneByType(ClientInterface::class);
+        } catch (DiscoveryFailedException $e) {
+            throw new RealNotFoundException('No PSR-18 clients found. Make sure to install a package providing "psr/http-client-implementation". Example: "php-http/guzzle7-adapter".', 0, $e);
+        }
+        return static::instantiateClass($client);
+    }
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Strategy/CommonClassesStrategy.php

@@ -0,0 +1,116 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Strategy;
+
+use WordPress\AiClientDependencies\GuzzleHttp\Client as GuzzleHttp;
+use WordPress\AiClientDependencies\GuzzleHttp\Promise\Promise;
+use WordPress\AiClientDependencies\GuzzleHttp\Psr7\Request as GuzzleRequest;
+use WordPress\AiClientDependencies\Http\Adapter\Artax\Client as Artax;
+use WordPress\AiClientDependencies\Http\Adapter\Buzz\Client as Buzz;
+use WordPress\AiClientDependencies\Http\Adapter\Cake\Client as Cake;
+use WordPress\AiClientDependencies\Http\Adapter\Guzzle5\Client as Guzzle5;
+use WordPress\AiClientDependencies\Http\Adapter\Guzzle6\Client as Guzzle6;
+use WordPress\AiClientDependencies\Http\Adapter\Guzzle7\Client as Guzzle7;
+use WordPress\AiClientDependencies\Http\Adapter\React\Client as React;
+use WordPress\AiClientDependencies\Http\Client\Curl\Client as Curl;
+use WordPress\AiClientDependencies\Http\Client\HttpAsyncClient;
+use WordPress\AiClientDependencies\Http\Client\HttpClient;
+use WordPress\AiClientDependencies\Http\Client\Socket\Client as Socket;
+use WordPress\AiClientDependencies\Http\Discovery\ClassDiscovery;
+use WordPress\AiClientDependencies\Http\Discovery\Exception\NotFoundException;
+use WordPress\AiClientDependencies\Http\Discovery\Psr17FactoryDiscovery;
+use WordPress\AiClientDependencies\Http\Message\MessageFactory;
+use WordPress\AiClientDependencies\Http\Message\MessageFactory\DiactorosMessageFactory;
+use WordPress\AiClientDependencies\Http\Message\MessageFactory\GuzzleMessageFactory;
+use WordPress\AiClientDependencies\Http\Message\MessageFactory\SlimMessageFactory;
+use WordPress\AiClientDependencies\Http\Message\StreamFactory;
+use WordPress\AiClientDependencies\Http\Message\StreamFactory\DiactorosStreamFactory;
+use WordPress\AiClientDependencies\Http\Message\StreamFactory\GuzzleStreamFactory;
+use WordPress\AiClientDependencies\Http\Message\StreamFactory\SlimStreamFactory;
+use WordPress\AiClientDependencies\Http\Message\UriFactory;
+use WordPress\AiClientDependencies\Http\Message\UriFactory\DiactorosUriFactory;
+use WordPress\AiClientDependencies\Http\Message\UriFactory\GuzzleUriFactory;
+use WordPress\AiClientDependencies\Http\Message\UriFactory\SlimUriFactory;
+use WordPress\AiClientDependencies\Laminas\Diactoros\Request as DiactorosRequest;
+use WordPress\AiClientDependencies\Nyholm\Psr7\Factory\HttplugFactory as NyholmHttplugFactory;
+use WordPress\AiClientDependencies\Psr\Http\Client\ClientInterface as Psr18Client;
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestFactoryInterface as Psr17RequestFactory;
+use WordPress\AiClientDependencies\Slim\Http\Request as SlimRequest;
+use WordPress\AiClientDependencies\Symfony\Component\HttpClient\HttplugClient as SymfonyHttplug;
+use WordPress\AiClientDependencies\Symfony\Component\HttpClient\Psr18Client as SymfonyPsr18;
+/**
+ * @internal
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ *
+ * Don't miss updating src/Composer/Plugin.php when adding a new supported class.
+ */
+final class CommonClassesStrategy implements DiscoveryStrategy
+{
+    /**
+     * @var array
+     */
+    private static $classes = [MessageFactory::class => [['class' => NyholmHttplugFactory::class, 'condition' => [NyholmHttplugFactory::class]], ['class' => GuzzleMessageFactory::class, 'condition' => [GuzzleRequest::class, GuzzleMessageFactory::class]], ['class' => DiactorosMessageFactory::class, 'condition' => [DiactorosRequest::class, DiactorosMessageFactory::class]], ['class' => SlimMessageFactory::class, 'condition' => [SlimRequest::class, SlimMessageFactory::class]]], StreamFactory::class => [['class' => NyholmHttplugFactory::class, 'condition' => [NyholmHttplugFactory::class]], ['class' => GuzzleStreamFactory::class, 'condition' => [GuzzleRequest::class, GuzzleStreamFactory::class]], ['class' => DiactorosStreamFactory::class, 'condition' => [DiactorosRequest::class, DiactorosStreamFactory::class]], ['class' => SlimStreamFactory::class, 'condition' => [SlimRequest::class, SlimStreamFactory::class]]], UriFactory::class => [['class' => NyholmHttplugFactory::class, 'condition' => [NyholmHttplugFactory::class]], ['class' => GuzzleUriFactory::class, 'condition' => [GuzzleRequest::class, GuzzleUriFactory::class]], ['class' => DiactorosUriFactory::class, 'condition' => [DiactorosRequest::class, DiactorosUriFactory::class]], ['class' => SlimUriFactory::class, 'condition' => [SlimRequest::class, SlimUriFactory::class]]], HttpAsyncClient::class => [['class' => SymfonyHttplug::class, 'condition' => [SymfonyHttplug::class, Promise::class, [self::class, 'isPsr17FactoryInstalled']]], ['class' => Guzzle7::class, 'condition' => Guzzle7::class], ['class' => Guzzle6::class, 'condition' => Guzzle6::class], ['class' => Curl::class, 'condition' => Curl::class], ['class' => React::class, 'condition' => React::class]], HttpClient::class => [['class' => SymfonyHttplug::class, 'condition' => [SymfonyHttplug::class, [self::class, 'isPsr17FactoryInstalled'], [self::class, 'isSymfonyImplementingHttpClient']]], ['class' => Guzzle7::class, 'condition' => Guzzle7::class], ['class' => Guzzle6::class, 'condition' => Guzzle6::class], ['class' => Guzzle5::class, 'condition' => Guzzle5::class], ['class' => Curl::class, 'condition' => Curl::class], ['class' => Socket::class, 'condition' => Socket::class], ['class' => Buzz::class, 'condition' => Buzz::class], ['class' => React::class, 'condition' => React::class], ['class' => Cake::class, 'condition' => Cake::class], ['class' => Artax::class, 'condition' => Artax::class], ['class' => [self::class, 'buzzInstantiate'], 'condition' => [\WordPress\AiClientDependencies\Buzz\Client\FileGetContents::class, \WordPress\AiClientDependencies\Buzz\Message\ResponseBuilder::class]]], Psr18Client::class => [['class' => [self::class, 'symfonyPsr18Instantiate'], 'condition' => [SymfonyPsr18::class, Psr17RequestFactory::class]], ['class' => GuzzleHttp::class, 'condition' => [self::class, 'isGuzzleImplementingPsr18']], ['class' => [self::class, 'buzzInstantiate'], 'condition' => [\WordPress\AiClientDependencies\Buzz\Client\FileGetContents::class, \WordPress\AiClientDependencies\Buzz\Message\ResponseBuilder::class]]]];
+    public static function getCandidates($type)
+    {
+        if (Psr18Client::class === $type) {
+            return self::getPsr18Candidates();
+        }
+        return self::$classes[$type] ?? [];
+    }
+    /**
+     * @return array The return value is always an array with zero or more elements. Each
+     *               element is an array with two keys ['class' => string, 'condition' => mixed].
+     */
+    private static function getPsr18Candidates()
+    {
+        $candidates = self::$classes[Psr18Client::class];
+        // HTTPlug 2.0 clients implements PSR18Client too.
+        foreach (self::$classes[HttpClient::class] as $c) {
+            if (!is_string($c['class'])) {
+                continue;
+            }
+            try {
+                if (ClassDiscovery::safeClassExists($c['class']) && is_subclass_of($c['class'], Psr18Client::class)) {
+                    $candidates[] = $c;
+                }
+            } catch (\Throwable $e) {
+                trigger_error(sprintf('Got exception "%s (%s)" while checking if a PSR-18 Client is available', get_class($e), $e->getMessage()), \E_USER_WARNING);
+            }
+        }
+        return $candidates;
+    }
+    public static function buzzInstantiate()
+    {
+        return new \WordPress\AiClientDependencies\Buzz\Client\FileGetContents(Psr17FactoryDiscovery::findResponseFactory());
+    }
+    public static function symfonyPsr18Instantiate()
+    {
+        return new SymfonyPsr18(null, Psr17FactoryDiscovery::findResponseFactory(), Psr17FactoryDiscovery::findStreamFactory());
+    }
+    public static function isGuzzleImplementingPsr18()
+    {
+        return defined('GuzzleHttp\ClientInterface::MAJOR_VERSION');
+    }
+    public static function isSymfonyImplementingHttpClient()
+    {
+        return is_subclass_of(SymfonyHttplug::class, HttpClient::class);
+    }
+    /**
+     * Can be used as a condition.
+     *
+     * @return bool
+     */
+    public static function isPsr17FactoryInstalled()
+    {
+        try {
+            Psr17FactoryDiscovery::findResponseFactory();
+        } catch (NotFoundException $e) {
+            return \false;
+        } catch (\Throwable $e) {
+            trigger_error(sprintf('Got exception "%s (%s)" while checking if a PSR-17 ResponseFactory is available', get_class($e), $e->getMessage()), \E_USER_WARNING);
+            return \false;
+        }
+        return \true;
+    }
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Strategy/CommonPsr17ClassesStrategy.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Strategy;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ResponseFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ServerRequestFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UploadedFileFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UriFactoryInterface;
+/**
+ * @internal
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ *
+ * Don't miss updating src/Composer/Plugin.php when adding a new supported class.
+ */
+final class CommonPsr17ClassesStrategy implements DiscoveryStrategy
+{
+    /**
+     * @var array
+     */
+    private static $classes = [RequestFactoryInterface::class => ['Phalcon\Http\Message\RequestFactory', 'Nyholm\Psr7\Factory\Psr17Factory', 'GuzzleHttp\Psr7\HttpFactory', 'WordPress\AiClientDependencies\Http\Factory\Diactoros\RequestFactory', 'WordPress\AiClientDependencies\Http\Factory\Guzzle\RequestFactory', 'WordPress\AiClientDependencies\Http\Factory\Slim\RequestFactory', 'Laminas\Diactoros\RequestFactory', 'Slim\Psr7\Factory\RequestFactory', 'WordPress\AiClientDependencies\HttpSoft\Message\RequestFactory'], ResponseFactoryInterface::class => ['Phalcon\Http\Message\ResponseFactory', 'Nyholm\Psr7\Factory\Psr17Factory', 'GuzzleHttp\Psr7\HttpFactory', 'WordPress\AiClientDependencies\Http\Factory\Diactoros\ResponseFactory', 'WordPress\AiClientDependencies\Http\Factory\Guzzle\ResponseFactory', 'WordPress\AiClientDependencies\Http\Factory\Slim\ResponseFactory', 'Laminas\Diactoros\ResponseFactory', 'Slim\Psr7\Factory\ResponseFactory', 'WordPress\AiClientDependencies\HttpSoft\Message\ResponseFactory'], ServerRequestFactoryInterface::class => ['Phalcon\Http\Message\ServerRequestFactory', 'Nyholm\Psr7\Factory\Psr17Factory', 'GuzzleHttp\Psr7\HttpFactory', 'WordPress\AiClientDependencies\Http\Factory\Diactoros\ServerRequestFactory', 'WordPress\AiClientDependencies\Http\Factory\Guzzle\ServerRequestFactory', 'WordPress\AiClientDependencies\Http\Factory\Slim\ServerRequestFactory', 'Laminas\Diactoros\ServerRequestFactory', 'Slim\Psr7\Factory\ServerRequestFactory', 'WordPress\AiClientDependencies\HttpSoft\Message\ServerRequestFactory'], StreamFactoryInterface::class => ['Phalcon\Http\Message\StreamFactory', 'Nyholm\Psr7\Factory\Psr17Factory', 'GuzzleHttp\Psr7\HttpFactory', 'WordPress\AiClientDependencies\Http\Factory\Diactoros\StreamFactory', 'WordPress\AiClientDependencies\Http\Factory\Guzzle\StreamFactory', 'WordPress\AiClientDependencies\Http\Factory\Slim\StreamFactory', 'Laminas\Diactoros\StreamFactory', 'Slim\Psr7\Factory\StreamFactory', 'WordPress\AiClientDependencies\HttpSoft\Message\StreamFactory'], UploadedFileFactoryInterface::class => ['Phalcon\Http\Message\UploadedFileFactory', 'Nyholm\Psr7\Factory\Psr17Factory', 'GuzzleHttp\Psr7\HttpFactory', 'WordPress\AiClientDependencies\Http\Factory\Diactoros\UploadedFileFactory', 'WordPress\AiClientDependencies\Http\Factory\Guzzle\UploadedFileFactory', 'WordPress\AiClientDependencies\Http\Factory\Slim\UploadedFileFactory', 'Laminas\Diactoros\UploadedFileFactory', 'Slim\Psr7\Factory\UploadedFileFactory', 'WordPress\AiClientDependencies\HttpSoft\Message\UploadedFileFactory'], UriFactoryInterface::class => ['Phalcon\Http\Message\UriFactory', 'Nyholm\Psr7\Factory\Psr17Factory', 'GuzzleHttp\Psr7\HttpFactory', 'WordPress\AiClientDependencies\Http\Factory\Diactoros\UriFactory', 'WordPress\AiClientDependencies\Http\Factory\Guzzle\UriFactory', 'WordPress\AiClientDependencies\Http\Factory\Slim\UriFactory', 'Laminas\Diactoros\UriFactory', 'Slim\Psr7\Factory\UriFactory', 'WordPress\AiClientDependencies\HttpSoft\Message\UriFactory']];
+    public static function getCandidates($type)
+    {
+        $candidates = [];
+        if (isset(self::$classes[$type])) {
+            foreach (self::$classes[$type] as $class) {
+                $candidates[] = ['class' => $class, 'condition' => [$class]];
+            }
+        }
+        return $candidates;
+    }
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Strategy/DiscoveryStrategy.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Strategy;
+
+use WordPress\AiClientDependencies\Http\Discovery\Exception\StrategyUnavailableException;
+/**
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+interface DiscoveryStrategy
+{
+    /**
+     * Find a resource of a specific type.
+     *
+     * @param string $type
+     *
+     * @return array The return value is always an array with zero or more elements. Each
+     *               element is an array with two keys ['class' => string, 'condition' => mixed].
+     *
+     * @throws StrategyUnavailableException if we cannot use this strategy
+     */
+    public static function getCandidates($type);
+}

wp-includes/php-ai-client/third-party/Http/Discovery/Strategy/PuliBetaStrategy.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Http\Discovery\Strategy;
+
+use WordPress\AiClientDependencies\Http\Discovery\ClassDiscovery;
+use WordPress\AiClientDependencies\Http\Discovery\Exception\PuliUnavailableException;
+use WordPress\AiClientDependencies\Puli\Discovery\Api\Discovery;
+use WordPress\AiClientDependencies\Puli\GeneratedPuliFactory;
+/**
+ * Find candidates using Puli.
+ *
+ * @internal
+ *
+ * @final
+ *
+ * @author David de Boer <david@ddeboer.nl>
+ * @author Márk Sági-Kazár <mark.sagikazar@gmail.com>
+ */
+class PuliBetaStrategy implements DiscoveryStrategy
+{
+    /**
+     * @var GeneratedPuliFactory
+     */
+    protected static $puliFactory;
+    /**
+     * @var Discovery
+     */
+    protected static $puliDiscovery;
+    /**
+     * @return GeneratedPuliFactory
+     *
+     * @throws PuliUnavailableException
+     */
+    private static function getPuliFactory()
+    {
+        if (null === self::$puliFactory) {
+            if (!defined('PULI_FACTORY_CLASS')) {
+                throw new PuliUnavailableException('Puli Factory is not available');
+            }
+            $puliFactoryClass = PULI_FACTORY_CLASS;
+            if (!ClassDiscovery::safeClassExists($puliFactoryClass)) {
+                throw new PuliUnavailableException('Puli Factory class does not exist');
+            }
+            self::$puliFactory = new $puliFactoryClass();
+        }
+        return self::$puliFactory;
+    }
+    /**
+     * Returns the Puli discovery layer.
+     *
+     * @return Discovery
+     *
+     * @throws PuliUnavailableException
+     */
+    private static function getPuliDiscovery()
+    {
+        if (!isset(self::$puliDiscovery)) {
+            $factory = self::getPuliFactory();
+            $repository = $factory->createRepository();
+            self::$puliDiscovery = $factory->createDiscovery($repository);
+        }
+        return self::$puliDiscovery;
+    }
+    public static function getCandidates($type)
+    {
+        $returnData = [];
+        $bindings = self::getPuliDiscovery()->findBindings($type);
+        foreach ($bindings as $binding) {
+            $condition = \true;
+            if ($binding->hasParameterValue('depends')) {
+                $condition = $binding->getParameterValue('depends');
+            }
+            $returnData[] = ['class' => $binding->getClassName(), 'condition' => $condition];
+        }
+        return $returnData;
+    }
+}