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;
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/Factory/HttplugFactory.php

@@ -0,0 +1,50 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7\Factory;
+
+use WordPress\AiClientDependencies\Http\Message\MessageFactory;
+use WordPress\AiClientDependencies\Http\Message\StreamFactory;
+use WordPress\AiClientDependencies\Http\Message\UriFactory;
+use WordPress\AiClientDependencies\Nyholm\Psr7\Request;
+use WordPress\AiClientDependencies\Nyholm\Psr7\Response;
+use WordPress\AiClientDependencies\Nyholm\Psr7\Stream;
+use WordPress\AiClientDependencies\Nyholm\Psr7\Uri;
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ResponseInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UriInterface;
+if (!\interface_exists(MessageFactory::class)) {
+    throw new \LogicException('You cannot use "Nyholm\Psr7\Factory\HttplugFactory" as the "php-http/message-factory" package is not installed. Try running "composer require php-http/message-factory". Note that this package is deprecated, use "psr/http-factory" instead');
+}
+@\trigger_error('Class "Nyholm\Psr7\Factory\HttplugFactory" is deprecated since version 1.8, use "Nyholm\Psr7\Factory\Psr17Factory" instead.', \E_USER_DEPRECATED);
+/**
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @final This class should never be extended. See https://github.com/Nyholm/psr7/blob/master/doc/final.md
+ *
+ * @deprecated since version 1.8, use Psr17Factory instead
+ */
+class HttplugFactory implements MessageFactory, StreamFactory, UriFactory
+{
+    public function createRequest($method, $uri, array $headers = [], $body = null, $protocolVersion = '1.1'): RequestInterface
+    {
+        return new Request($method, $uri, $headers, $body, $protocolVersion);
+    }
+    public function createResponse($statusCode = 200, $reasonPhrase = null, array $headers = [], $body = null, $version = '1.1'): ResponseInterface
+    {
+        return new Response((int) $statusCode, $headers, $body, $version, $reasonPhrase);
+    }
+    public function createStream($body = null): StreamInterface
+    {
+        return Stream::create($body ?? '');
+    }
+    public function createUri($uri = ''): UriInterface
+    {
+        if ($uri instanceof UriInterface) {
+            return $uri;
+        }
+        return new Uri($uri);
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/Factory/Psr17Factory.php

@@ -0,0 +1,80 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7\Factory;
+
+use WordPress\AiClientDependencies\Nyholm\Psr7\Request;
+use WordPress\AiClientDependencies\Nyholm\Psr7\Response;
+use WordPress\AiClientDependencies\Nyholm\Psr7\ServerRequest;
+use WordPress\AiClientDependencies\Nyholm\Psr7\Stream;
+use WordPress\AiClientDependencies\Nyholm\Psr7\UploadedFile;
+use WordPress\AiClientDependencies\Nyholm\Psr7\Uri;
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ResponseFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ResponseInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ServerRequestFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ServerRequestInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UploadedFileFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UploadedFileInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UriFactoryInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UriInterface;
+/**
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @final This class should never be extended. See https://github.com/Nyholm/psr7/blob/master/doc/final.md
+ */
+class Psr17Factory implements RequestFactoryInterface, ResponseFactoryInterface, ServerRequestFactoryInterface, StreamFactoryInterface, UploadedFileFactoryInterface, UriFactoryInterface
+{
+    public function createRequest(string $method, $uri): RequestInterface
+    {
+        return new Request($method, $uri);
+    }
+    public function createResponse(int $code = 200, string $reasonPhrase = ''): ResponseInterface
+    {
+        if (2 > \func_num_args()) {
+            // This will make the Response class to use a custom reasonPhrase
+            $reasonPhrase = null;
+        }
+        return new Response($code, [], null, '1.1', $reasonPhrase);
+    }
+    public function createStream(string $content = ''): StreamInterface
+    {
+        return Stream::create($content);
+    }
+    public function createStreamFromFile(string $filename, string $mode = 'r'): StreamInterface
+    {
+        if ('' === $filename) {
+            throw new \RuntimeException('Path cannot be empty');
+        }
+        if (\false === $resource = @\fopen($filename, $mode)) {
+            if ('' === $mode || \false === \in_array($mode[0], ['r', 'w', 'a', 'x', 'c'], \true)) {
+                throw new \InvalidArgumentException(\sprintf('The mode "%s" is invalid.', $mode));
+            }
+            throw new \RuntimeException(\sprintf('The file "%s" cannot be opened: %s', $filename, \error_get_last()['message'] ?? ''));
+        }
+        return Stream::create($resource);
+    }
+    public function createStreamFromResource($resource): StreamInterface
+    {
+        return Stream::create($resource);
+    }
+    public function createUploadedFile(StreamInterface $stream, ?int $size = null, int $error = \UPLOAD_ERR_OK, ?string $clientFilename = null, ?string $clientMediaType = null): UploadedFileInterface
+    {
+        if (null === $size) {
+            $size = $stream->getSize();
+        }
+        return new UploadedFile($stream, $size, $error, $clientFilename, $clientMediaType);
+    }
+    public function createUri(string $uri = ''): UriInterface
+    {
+        return new Uri($uri);
+    }
+    public function createServerRequest(string $method, $uri, array $serverParams = []): ServerRequestInterface
+    {
+        return new ServerRequest($method, $uri, [], null, '1.1', $serverParams);
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/MessageTrait.php

@@ -0,0 +1,195 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\MessageInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamInterface;
+/**
+ * Trait implementing functionality common to requests and responses.
+ *
+ * @author Michael Dowling and contributors to guzzlehttp/psr7
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @internal should not be used outside of Nyholm/Psr7 as it does not fall under our BC promise
+ */
+trait MessageTrait
+{
+    /** @var array Map of all registered headers, as original name => array of values */
+    private $headers = [];
+    /** @var array Map of lowercase header name => original name at registration */
+    private $headerNames = [];
+    /** @var string */
+    private $protocol = '1.1';
+    /** @var StreamInterface|null */
+    private $stream;
+    public function getProtocolVersion(): string
+    {
+        return $this->protocol;
+    }
+    /**
+     * @return static
+     */
+    public function withProtocolVersion($version): MessageInterface
+    {
+        if (!\is_scalar($version)) {
+            throw new \InvalidArgumentException('Protocol version must be a string');
+        }
+        if ($this->protocol === $version) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->protocol = (string) $version;
+        return $new;
+    }
+    public function getHeaders(): array
+    {
+        return $this->headers;
+    }
+    public function hasHeader($header): bool
+    {
+        return isset($this->headerNames[\strtr($header, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')]);
+    }
+    public function getHeader($header): array
+    {
+        if (!\is_string($header)) {
+            throw new \InvalidArgumentException('Header name must be an RFC 7230 compatible string');
+        }
+        $header = \strtr($header, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz');
+        if (!isset($this->headerNames[$header])) {
+            return [];
+        }
+        $header = $this->headerNames[$header];
+        return $this->headers[$header];
+    }
+    public function getHeaderLine($header): string
+    {
+        return \implode(', ', $this->getHeader($header));
+    }
+    /**
+     * @return static
+     */
+    public function withHeader($header, $value): MessageInterface
+    {
+        $value = $this->validateAndTrimHeader($header, $value);
+        $normalized = \strtr($header, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz');
+        $new = clone $this;
+        if (isset($new->headerNames[$normalized])) {
+            unset($new->headers[$new->headerNames[$normalized]]);
+        }
+        $new->headerNames[$normalized] = $header;
+        $new->headers[$header] = $value;
+        return $new;
+    }
+    /**
+     * @return static
+     */
+    public function withAddedHeader($header, $value): MessageInterface
+    {
+        if (!\is_string($header) || '' === $header) {
+            throw new \InvalidArgumentException('Header name must be an RFC 7230 compatible string');
+        }
+        $new = clone $this;
+        $new->setHeaders([$header => $value]);
+        return $new;
+    }
+    /**
+     * @return static
+     */
+    public function withoutHeader($header): MessageInterface
+    {
+        if (!\is_string($header)) {
+            throw new \InvalidArgumentException('Header name must be an RFC 7230 compatible string');
+        }
+        $normalized = \strtr($header, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz');
+        if (!isset($this->headerNames[$normalized])) {
+            return $this;
+        }
+        $header = $this->headerNames[$normalized];
+        $new = clone $this;
+        unset($new->headers[$header], $new->headerNames[$normalized]);
+        return $new;
+    }
+    public function getBody(): StreamInterface
+    {
+        if (null === $this->stream) {
+            $this->stream = Stream::create('');
+        }
+        return $this->stream;
+    }
+    /**
+     * @return static
+     */
+    public function withBody(StreamInterface $body): MessageInterface
+    {
+        if ($body === $this->stream) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->stream = $body;
+        return $new;
+    }
+    private function setHeaders(array $headers): void
+    {
+        foreach ($headers as $header => $value) {
+            if (\is_int($header)) {
+                // If a header name was set to a numeric string, PHP will cast the key to an int.
+                // We must cast it back to a string in order to comply with validation.
+                $header = (string) $header;
+            }
+            $value = $this->validateAndTrimHeader($header, $value);
+            $normalized = \strtr($header, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz');
+            if (isset($this->headerNames[$normalized])) {
+                $header = $this->headerNames[$normalized];
+                $this->headers[$header] = \array_merge($this->headers[$header], $value);
+            } else {
+                $this->headerNames[$normalized] = $header;
+                $this->headers[$header] = $value;
+            }
+        }
+    }
+    /**
+     * Make sure the header complies with RFC 7230.
+     *
+     * Header names must be a non-empty string consisting of token characters.
+     *
+     * Header values must be strings consisting of visible characters with all optional
+     * leading and trailing whitespace stripped. This method will always strip such
+     * optional whitespace. Note that the method does not allow folding whitespace within
+     * the values as this was deprecated for almost all instances by the RFC.
+     *
+     * header-field = field-name ":" OWS field-value OWS
+     * field-name   = 1*( "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." / "^"
+     *              / "_" / "`" / "|" / "~" / %x30-39 / ( %x41-5A / %x61-7A ) )
+     * OWS          = *( SP / HTAB )
+     * field-value  = *( ( %x21-7E / %x80-FF ) [ 1*( SP / HTAB ) ( %x21-7E / %x80-FF ) ] )
+     *
+     * @see https://tools.ietf.org/html/rfc7230#section-3.2.4
+     */
+    private function validateAndTrimHeader($header, $values): array
+    {
+        if (!\is_string($header) || 1 !== \preg_match("@^[!#\$%&'*+.^_`|~0-9A-Za-z-]+\$@D", $header)) {
+            throw new \InvalidArgumentException('Header name must be an RFC 7230 compatible string');
+        }
+        if (!\is_array($values)) {
+            // This is simple, just one value.
+            if (!\is_numeric($values) && !\is_string($values) || 1 !== \preg_match("@^[ \t!-~\x80-\xff]*\$@", (string) $values)) {
+                throw new \InvalidArgumentException('Header values must be RFC 7230 compatible strings');
+            }
+            return [\trim((string) $values, " \t")];
+        }
+        if (empty($values)) {
+            throw new \InvalidArgumentException('Header values must be a string or an array of strings, empty array given');
+        }
+        // Assert Non empty array
+        $returnValues = [];
+        foreach ($values as $v) {
+            if (!\is_numeric($v) && !\is_string($v) || 1 !== \preg_match("@^[ \t!-~\x80-\xff]*\$@D", (string) $v)) {
+                throw new \InvalidArgumentException('Header values must be RFC 7230 compatible strings');
+            }
+            $returnValues[] = \trim((string) $v, " \t");
+        }
+        return $returnValues;
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/Request.php

@@ -0,0 +1,43 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UriInterface;
+/**
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @final This class should never be extended. See https://github.com/Nyholm/psr7/blob/master/doc/final.md
+ */
+class Request implements RequestInterface
+{
+    use MessageTrait;
+    use RequestTrait;
+    /**
+     * @param string $method HTTP method
+     * @param string|UriInterface $uri URI
+     * @param array $headers Request headers
+     * @param string|resource|StreamInterface|null $body Request body
+     * @param string $version Protocol version
+     */
+    public function __construct(string $method, $uri, array $headers = [], $body = null, string $version = '1.1')
+    {
+        if (!$uri instanceof UriInterface) {
+            $uri = new Uri($uri);
+        }
+        $this->method = $method;
+        $this->uri = $uri;
+        $this->setHeaders($headers);
+        $this->protocol = $version;
+        if (!$this->hasHeader('Host')) {
+            $this->updateHostFromUri();
+        }
+        // If we got no body, defer initialization of the stream until Request::getBody()
+        if ('' !== $body && null !== $body) {
+            $this->stream = Stream::create($body);
+        }
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/RequestTrait.php

@@ -0,0 +1,103 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UriInterface;
+/**
+ * @author Michael Dowling and contributors to guzzlehttp/psr7
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @internal should not be used outside of Nyholm/Psr7 as it does not fall under our BC promise
+ */
+trait RequestTrait
+{
+    /** @var string */
+    private $method;
+    /** @var string|null */
+    private $requestTarget;
+    /** @var UriInterface|null */
+    private $uri;
+    public function getRequestTarget(): string
+    {
+        if (null !== $this->requestTarget) {
+            return $this->requestTarget;
+        }
+        if ('' === $target = $this->uri->getPath()) {
+            $target = '/';
+        }
+        if ('' !== $this->uri->getQuery()) {
+            $target .= '?' . $this->uri->getQuery();
+        }
+        return $target;
+    }
+    /**
+     * @return static
+     */
+    public function withRequestTarget($requestTarget): RequestInterface
+    {
+        if (!\is_string($requestTarget)) {
+            throw new \InvalidArgumentException('Request target must be a string');
+        }
+        if (\preg_match('#\s#', $requestTarget)) {
+            throw new \InvalidArgumentException('Invalid request target provided; cannot contain whitespace');
+        }
+        $new = clone $this;
+        $new->requestTarget = $requestTarget;
+        return $new;
+    }
+    public function getMethod(): string
+    {
+        return $this->method;
+    }
+    /**
+     * @return static
+     */
+    public function withMethod($method): RequestInterface
+    {
+        if (!\is_string($method)) {
+            throw new \InvalidArgumentException('Method must be a string');
+        }
+        $new = clone $this;
+        $new->method = $method;
+        return $new;
+    }
+    public function getUri(): UriInterface
+    {
+        return $this->uri;
+    }
+    /**
+     * @return static
+     */
+    public function withUri(UriInterface $uri, $preserveHost = \false): RequestInterface
+    {
+        if ($uri === $this->uri) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->uri = $uri;
+        if (!$preserveHost || !$this->hasHeader('Host')) {
+            $new->updateHostFromUri();
+        }
+        return $new;
+    }
+    private function updateHostFromUri(): void
+    {
+        if ('' === $host = $this->uri->getHost()) {
+            return;
+        }
+        if (null !== $port = $this->uri->getPort()) {
+            $host .= ':' . $port;
+        }
+        if (isset($this->headerNames['host'])) {
+            $header = $this->headerNames['host'];
+        } else {
+            $this->headerNames['host'] = $header = 'Host';
+        }
+        // Ensure Host is the first header.
+        // See: http://tools.ietf.org/html/rfc7230#section-5.4
+        $this->headers = [$header => [$host]] + $this->headers;
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/Response.php

@@ -0,0 +1,74 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\ResponseInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamInterface;
+/**
+ * @author Michael Dowling and contributors to guzzlehttp/psr7
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @final This class should never be extended. See https://github.com/Nyholm/psr7/blob/master/doc/final.md
+ */
+class Response implements ResponseInterface
+{
+    use MessageTrait;
+    /** @var array Map of standard HTTP status code/reason phrases */
+    private const PHRASES = [100 => 'Continue', 101 => 'Switching Protocols', 102 => 'Processing', 200 => 'OK', 201 => 'Created', 202 => 'Accepted', 203 => 'Non-Authoritative Information', 204 => 'No Content', 205 => 'Reset Content', 206 => 'Partial Content', 207 => 'Multi-status', 208 => 'Already Reported', 300 => 'Multiple Choices', 301 => 'Moved Permanently', 302 => 'Found', 303 => 'See Other', 304 => 'Not Modified', 305 => 'Use Proxy', 306 => 'Switch Proxy', 307 => 'Temporary Redirect', 400 => 'Bad Request', 401 => 'Unauthorized', 402 => 'Payment Required', 403 => 'Forbidden', 404 => 'Not Found', 405 => 'Method Not Allowed', 406 => 'Not Acceptable', 407 => 'Proxy Authentication Required', 408 => 'Request Time-out', 409 => 'Conflict', 410 => 'Gone', 411 => 'Length Required', 412 => 'Precondition Failed', 413 => 'Request Entity Too Large', 414 => 'Request-URI Too Large', 415 => 'Unsupported Media Type', 416 => 'Requested range not satisfiable', 417 => 'Expectation Failed', 418 => 'I\'m a teapot', 422 => 'Unprocessable Entity', 423 => 'Locked', 424 => 'Failed Dependency', 425 => 'Unordered Collection', 426 => 'Upgrade Required', 428 => 'Precondition Required', 429 => 'Too Many Requests', 431 => 'Request Header Fields Too Large', 451 => 'Unavailable For Legal Reasons', 500 => 'Internal Server Error', 501 => 'Not Implemented', 502 => 'Bad Gateway', 503 => 'Service Unavailable', 504 => 'Gateway Time-out', 505 => 'HTTP Version not supported', 506 => 'Variant Also Negotiates', 507 => 'Insufficient Storage', 508 => 'Loop Detected', 511 => 'Network Authentication Required'];
+    /** @var string */
+    private $reasonPhrase = '';
+    /** @var int */
+    private $statusCode;
+    /**
+     * @param int $status Status code
+     * @param array $headers Response headers
+     * @param string|resource|StreamInterface|null $body Response body
+     * @param string $version Protocol version
+     * @param string|null $reason Reason phrase (when empty a default will be used based on the status code)
+     */
+    public function __construct(int $status = 200, array $headers = [], $body = null, string $version = '1.1', ?string $reason = null)
+    {
+        // If we got no body, defer initialization of the stream until Response::getBody()
+        if ('' !== $body && null !== $body) {
+            $this->stream = Stream::create($body);
+        }
+        $this->statusCode = $status;
+        $this->setHeaders($headers);
+        if (null === $reason && isset(self::PHRASES[$this->statusCode])) {
+            $this->reasonPhrase = self::PHRASES[$status];
+        } else {
+            $this->reasonPhrase = $reason ?? '';
+        }
+        $this->protocol = $version;
+    }
+    public function getStatusCode(): int
+    {
+        return $this->statusCode;
+    }
+    public function getReasonPhrase(): string
+    {
+        return $this->reasonPhrase;
+    }
+    /**
+     * @return static
+     */
+    public function withStatus($code, $reasonPhrase = ''): ResponseInterface
+    {
+        if (!\is_int($code) && !\is_string($code)) {
+            throw new \InvalidArgumentException('Status code has to be an integer');
+        }
+        $code = (int) $code;
+        if ($code < 100 || $code > 599) {
+            throw new \InvalidArgumentException(\sprintf('Status code has to be an integer between 100 and 599. A status code of %d was given', $code));
+        }
+        $new = clone $this;
+        $new->statusCode = $code;
+        if ((null === $reasonPhrase || '' === $reasonPhrase) && isset(self::PHRASES[$new->statusCode])) {
+            $reasonPhrase = self::PHRASES[$new->statusCode];
+        }
+        $new->reasonPhrase = $reasonPhrase;
+        return $new;
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/ServerRequest.php

@@ -0,0 +1,166 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\ServerRequestInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UploadedFileInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UriInterface;
+/**
+ * @author Michael Dowling and contributors to guzzlehttp/psr7
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @final This class should never be extended. See https://github.com/Nyholm/psr7/blob/master/doc/final.md
+ */
+class ServerRequest implements ServerRequestInterface
+{
+    use MessageTrait;
+    use RequestTrait;
+    /** @var array */
+    private $attributes = [];
+    /** @var array */
+    private $cookieParams = [];
+    /** @var array|object|null */
+    private $parsedBody;
+    /** @var array */
+    private $queryParams = [];
+    /** @var array */
+    private $serverParams;
+    /** @var UploadedFileInterface[] */
+    private $uploadedFiles = [];
+    /**
+     * @param string $method HTTP method
+     * @param string|UriInterface $uri URI
+     * @param array $headers Request headers
+     * @param string|resource|StreamInterface|null $body Request body
+     * @param string $version Protocol version
+     * @param array $serverParams Typically the $_SERVER superglobal
+     */
+    public function __construct(string $method, $uri, array $headers = [], $body = null, string $version = '1.1', array $serverParams = [])
+    {
+        $this->serverParams = $serverParams;
+        if (!$uri instanceof UriInterface) {
+            $uri = new Uri($uri);
+        }
+        $this->method = $method;
+        $this->uri = $uri;
+        $this->setHeaders($headers);
+        $this->protocol = $version;
+        \parse_str($uri->getQuery(), $this->queryParams);
+        if (!$this->hasHeader('Host')) {
+            $this->updateHostFromUri();
+        }
+        // If we got no body, defer initialization of the stream until ServerRequest::getBody()
+        if ('' !== $body && null !== $body) {
+            $this->stream = Stream::create($body);
+        }
+    }
+    public function getServerParams(): array
+    {
+        return $this->serverParams;
+    }
+    public function getUploadedFiles(): array
+    {
+        return $this->uploadedFiles;
+    }
+    /**
+     * @return static
+     */
+    public function withUploadedFiles(array $uploadedFiles): ServerRequestInterface
+    {
+        $new = clone $this;
+        $new->uploadedFiles = $uploadedFiles;
+        return $new;
+    }
+    public function getCookieParams(): array
+    {
+        return $this->cookieParams;
+    }
+    /**
+     * @return static
+     */
+    public function withCookieParams(array $cookies): ServerRequestInterface
+    {
+        $new = clone $this;
+        $new->cookieParams = $cookies;
+        return $new;
+    }
+    public function getQueryParams(): array
+    {
+        return $this->queryParams;
+    }
+    /**
+     * @return static
+     */
+    public function withQueryParams(array $query): ServerRequestInterface
+    {
+        $new = clone $this;
+        $new->queryParams = $query;
+        return $new;
+    }
+    /**
+     * @return array|object|null
+     */
+    public function getParsedBody()
+    {
+        return $this->parsedBody;
+    }
+    /**
+     * @return static
+     */
+    public function withParsedBody($data): ServerRequestInterface
+    {
+        if (!\is_array($data) && !\is_object($data) && null !== $data) {
+            throw new \InvalidArgumentException('First parameter to withParsedBody MUST be object, array or null');
+        }
+        $new = clone $this;
+        $new->parsedBody = $data;
+        return $new;
+    }
+    public function getAttributes(): array
+    {
+        return $this->attributes;
+    }
+    /**
+     * @return mixed
+     */
+    public function getAttribute($attribute, $default = null)
+    {
+        if (!\is_string($attribute)) {
+            throw new \InvalidArgumentException('Attribute name must be a string');
+        }
+        if (\false === \array_key_exists($attribute, $this->attributes)) {
+            return $default;
+        }
+        return $this->attributes[$attribute];
+    }
+    /**
+     * @return static
+     */
+    public function withAttribute($attribute, $value): ServerRequestInterface
+    {
+        if (!\is_string($attribute)) {
+            throw new \InvalidArgumentException('Attribute name must be a string');
+        }
+        $new = clone $this;
+        $new->attributes[$attribute] = $value;
+        return $new;
+    }
+    /**
+     * @return static
+     */
+    public function withoutAttribute($attribute): ServerRequestInterface
+    {
+        if (!\is_string($attribute)) {
+            throw new \InvalidArgumentException('Attribute name must be a string');
+        }
+        if (\false === \array_key_exists($attribute, $this->attributes)) {
+            return $this;
+        }
+        $new = clone $this;
+        unset($new->attributes[$attribute]);
+        return $new;
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/Stream.php

@@ -0,0 +1,311 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamInterface;
+/**
+ * @author Michael Dowling and contributors to guzzlehttp/psr7
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @final This class should never be extended. See https://github.com/Nyholm/psr7/blob/master/doc/final.md
+ */
+class Stream implements StreamInterface
+{
+    use StreamTrait;
+    /** @var resource|null A resource reference */
+    private $stream;
+    /** @var bool */
+    private $seekable;
+    /** @var bool */
+    private $readable;
+    /** @var bool */
+    private $writable;
+    /** @var array|mixed|void|bool|null */
+    private $uri;
+    /** @var int|null */
+    private $size;
+    /** @var array Hash of readable and writable stream types */
+    private const READ_WRITE_HASH = ['read' => ['r' => \true, 'w+' => \true, 'r+' => \true, 'x+' => \true, 'c+' => \true, 'rb' => \true, 'w+b' => \true, 'r+b' => \true, 'x+b' => \true, 'c+b' => \true, 'rt' => \true, 'w+t' => \true, 'r+t' => \true, 'x+t' => \true, 'c+t' => \true, 'a+' => \true], 'write' => ['w' => \true, 'w+' => \true, 'rw' => \true, 'r+' => \true, 'x+' => \true, 'c+' => \true, 'wb' => \true, 'w+b' => \true, 'r+b' => \true, 'x+b' => \true, 'c+b' => \true, 'w+t' => \true, 'r+t' => \true, 'x+t' => \true, 'c+t' => \true, 'a' => \true, 'a+' => \true]];
+    /**
+     * @param resource $body
+     */
+    public function __construct($body)
+    {
+        if (!\is_resource($body)) {
+            throw new \InvalidArgumentException('First argument to Stream::__construct() must be resource');
+        }
+        $this->stream = $body;
+        $meta = \stream_get_meta_data($this->stream);
+        $this->seekable = $meta['seekable'] && 0 === \fseek($this->stream, 0, \SEEK_CUR);
+        $this->readable = isset(self::READ_WRITE_HASH['read'][$meta['mode']]);
+        $this->writable = isset(self::READ_WRITE_HASH['write'][$meta['mode']]);
+    }
+    /**
+     * Creates a new PSR-7 stream.
+     *
+     * @param string|resource|StreamInterface $body
+     *
+     * @throws \InvalidArgumentException
+     */
+    public static function create($body = ''): StreamInterface
+    {
+        if ($body instanceof StreamInterface) {
+            return $body;
+        }
+        if (\is_string($body)) {
+            if (200000 <= \strlen($body)) {
+                $body = self::openZvalStream($body);
+            } else {
+                $resource = \fopen('php://memory', 'r+');
+                \fwrite($resource, $body);
+                \fseek($resource, 0);
+                $body = $resource;
+            }
+        }
+        if (!\is_resource($body)) {
+            throw new \InvalidArgumentException('First argument to Stream::create() must be a string, resource or StreamInterface');
+        }
+        return new self($body);
+    }
+    /**
+     * Closes the stream when the destructed.
+     */
+    public function __destruct()
+    {
+        $this->close();
+    }
+    public function close(): void
+    {
+        if (isset($this->stream)) {
+            if (\is_resource($this->stream)) {
+                \fclose($this->stream);
+            }
+            $this->detach();
+        }
+    }
+    public function detach()
+    {
+        if (!isset($this->stream)) {
+            return null;
+        }
+        $result = $this->stream;
+        unset($this->stream);
+        $this->size = $this->uri = null;
+        $this->readable = $this->writable = $this->seekable = \false;
+        return $result;
+    }
+    private function getUri()
+    {
+        if (\false !== $this->uri) {
+            $this->uri = $this->getMetadata('uri') ?? \false;
+        }
+        return $this->uri;
+    }
+    public function getSize(): ?int
+    {
+        if (null !== $this->size) {
+            return $this->size;
+        }
+        if (!isset($this->stream)) {
+            return null;
+        }
+        // Clear the stat cache if the stream has a URI
+        if ($uri = $this->getUri()) {
+            \clearstatcache(\true, $uri);
+        }
+        $stats = \fstat($this->stream);
+        if (isset($stats['size'])) {
+            $this->size = $stats['size'];
+            return $this->size;
+        }
+        return null;
+    }
+    public function tell(): int
+    {
+        if (!isset($this->stream)) {
+            throw new \RuntimeException('Stream is detached');
+        }
+        if (\false === $result = @\ftell($this->stream)) {
+            throw new \RuntimeException('Unable to determine stream position: ' . (\error_get_last()['message'] ?? ''));
+        }
+        return $result;
+    }
+    public function eof(): bool
+    {
+        return !isset($this->stream) || \feof($this->stream);
+    }
+    public function isSeekable(): bool
+    {
+        return $this->seekable;
+    }
+    public function seek($offset, $whence = \SEEK_SET): void
+    {
+        if (!isset($this->stream)) {
+            throw new \RuntimeException('Stream is detached');
+        }
+        if (!$this->seekable) {
+            throw new \RuntimeException('Stream is not seekable');
+        }
+        if (-1 === \fseek($this->stream, $offset, $whence)) {
+            throw new \RuntimeException('Unable to seek to stream position "' . $offset . '" with whence ' . \var_export($whence, \true));
+        }
+    }
+    public function rewind(): void
+    {
+        $this->seek(0);
+    }
+    public function isWritable(): bool
+    {
+        return $this->writable;
+    }
+    public function write($string): int
+    {
+        if (!isset($this->stream)) {
+            throw new \RuntimeException('Stream is detached');
+        }
+        if (!$this->writable) {
+            throw new \RuntimeException('Cannot write to a non-writable stream');
+        }
+        // We can't know the size after writing anything
+        $this->size = null;
+        if (\false === $result = @\fwrite($this->stream, $string)) {
+            throw new \RuntimeException('Unable to write to stream: ' . (\error_get_last()['message'] ?? ''));
+        }
+        return $result;
+    }
+    public function isReadable(): bool
+    {
+        return $this->readable;
+    }
+    public function read($length): string
+    {
+        if (!isset($this->stream)) {
+            throw new \RuntimeException('Stream is detached');
+        }
+        if (!$this->readable) {
+            throw new \RuntimeException('Cannot read from non-readable stream');
+        }
+        if (\false === $result = @\fread($this->stream, $length)) {
+            throw new \RuntimeException('Unable to read from stream: ' . (\error_get_last()['message'] ?? ''));
+        }
+        return $result;
+    }
+    public function getContents(): string
+    {
+        if (!isset($this->stream)) {
+            throw new \RuntimeException('Stream is detached');
+        }
+        $exception = null;
+        \set_error_handler(static function ($type, $message) use (&$exception) {
+            throw $exception = new \RuntimeException('Unable to read stream contents: ' . $message);
+        });
+        try {
+            return \stream_get_contents($this->stream);
+        } catch (\Throwable $e) {
+            throw $e === $exception ? $e : new \RuntimeException('Unable to read stream contents: ' . $e->getMessage(), 0, $e);
+        } finally {
+            \restore_error_handler();
+        }
+    }
+    /**
+     * @return mixed
+     */
+    public function getMetadata($key = null)
+    {
+        if (null !== $key && !\is_string($key)) {
+            throw new \InvalidArgumentException('Metadata key must be a string');
+        }
+        if (!isset($this->stream)) {
+            return $key ? null : [];
+        }
+        $meta = \stream_get_meta_data($this->stream);
+        if (null === $key) {
+            return $meta;
+        }
+        return $meta[$key] ?? null;
+    }
+    private static function openZvalStream(string $body)
+    {
+        static $wrapper;
+        $wrapper ?? \stream_wrapper_register('Nyholm-Psr7-Zval', $wrapper = \get_class(new class
+        {
+            public $context;
+            private $data;
+            private $position = 0;
+            public function stream_open(): bool
+            {
+                $this->data = \stream_context_get_options($this->context)['Nyholm-Psr7-Zval']['data'];
+                \stream_context_set_option($this->context, 'Nyholm-Psr7-Zval', 'data', null);
+                return \true;
+            }
+            public function stream_read(int $count): string
+            {
+                $result = \substr($this->data, $this->position, $count);
+                $this->position += \strlen($result);
+                return $result;
+            }
+            public function stream_write(string $data): int
+            {
+                $this->data = \substr_replace($this->data, $data, $this->position, \strlen($data));
+                $this->position += \strlen($data);
+                return \strlen($data);
+            }
+            public function stream_tell(): int
+            {
+                return $this->position;
+            }
+            public function stream_eof(): bool
+            {
+                return \strlen($this->data) <= $this->position;
+            }
+            public function stream_stat(): array
+            {
+                return [
+                    'mode' => 33206,
+                    // POSIX_S_IFREG | 0666
+                    'nlink' => 1,
+                    'rdev' => -1,
+                    'size' => \strlen($this->data),
+                    'blksize' => -1,
+                    'blocks' => -1,
+                ];
+            }
+            public function stream_seek(int $offset, int $whence): bool
+            {
+                if (\SEEK_SET === $whence && (0 <= $offset && \strlen($this->data) >= $offset)) {
+                    $this->position = $offset;
+                } elseif (\SEEK_CUR === $whence && 0 <= $offset) {
+                    $this->position += $offset;
+                } elseif (\SEEK_END === $whence && (0 > $offset && 0 <= $offset = \strlen($this->data) + $offset)) {
+                    $this->position = $offset;
+                } else {
+                    return \false;
+                }
+                return \true;
+            }
+            public function stream_set_option(): bool
+            {
+                return \true;
+            }
+            public function stream_truncate(int $new_size): bool
+            {
+                if ($new_size) {
+                    $this->data = \substr($this->data, 0, $new_size);
+                    $this->position = \min($this->position, $new_size);
+                } else {
+                    $this->data = '';
+                    $this->position = 0;
+                }
+                return \true;
+            }
+        }));
+        $context = \stream_context_create(['Nyholm-Psr7-Zval' => ['data' => $body]]);
+        if (!$stream = @\fopen('Nyholm-Psr7-Zval://', 'r+', \false, $context)) {
+            \stream_wrapper_register('Nyholm-Psr7-Zval', $wrapper);
+            $stream = \fopen('Nyholm-Psr7-Zval://', 'r+', \false, $context);
+        }
+        return $stream;
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/StreamTrait.php

@@ -0,0 +1,51 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamInterface;
+use WordPress\AiClientDependencies\Symfony\Component\Debug\ErrorHandler as SymfonyLegacyErrorHandler;
+use WordPress\AiClientDependencies\Symfony\Component\ErrorHandler\ErrorHandler as SymfonyErrorHandler;
+if (\PHP_VERSION_ID >= 70400 || (new \ReflectionMethod(StreamInterface::class, '__toString'))->hasReturnType()) {
+    /**
+     * @internal
+     */
+    trait StreamTrait
+    {
+        public function __toString(): string
+        {
+            if ($this->isSeekable()) {
+                $this->seek(0);
+            }
+            return $this->getContents();
+        }
+    }
+} else {
+    /**
+     * @internal
+     */
+    trait StreamTrait
+    {
+        /**
+         * @return string
+         */
+        public function __toString()
+        {
+            try {
+                if ($this->isSeekable()) {
+                    $this->seek(0);
+                }
+                return $this->getContents();
+            } catch (\Throwable $e) {
+                if (\is_array($errorHandler = \set_error_handler('var_dump'))) {
+                    $errorHandler = $errorHandler[0] ?? null;
+                }
+                \restore_error_handler();
+                if ($e instanceof \Error || $errorHandler instanceof SymfonyErrorHandler || $errorHandler instanceof SymfonyLegacyErrorHandler) {
+                    return \trigger_error((string) $e, \E_USER_ERROR);
+                }
+                return '';
+            }
+        }
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/UploadedFile.php

@@ -0,0 +1,138 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\StreamInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\UploadedFileInterface;
+/**
+ * @author Michael Dowling and contributors to guzzlehttp/psr7
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @final This class should never be extended. See https://github.com/Nyholm/psr7/blob/master/doc/final.md
+ */
+class UploadedFile implements UploadedFileInterface
+{
+    /** @var array */
+    private const ERRORS = [\UPLOAD_ERR_OK => 1, \UPLOAD_ERR_INI_SIZE => 1, \UPLOAD_ERR_FORM_SIZE => 1, \UPLOAD_ERR_PARTIAL => 1, \UPLOAD_ERR_NO_FILE => 1, \UPLOAD_ERR_NO_TMP_DIR => 1, \UPLOAD_ERR_CANT_WRITE => 1, \UPLOAD_ERR_EXTENSION => 1];
+    /** @var string */
+    private $clientFilename;
+    /** @var string */
+    private $clientMediaType;
+    /** @var int */
+    private $error;
+    /** @var string|null */
+    private $file;
+    /** @var bool */
+    private $moved = \false;
+    /** @var int */
+    private $size;
+    /** @var StreamInterface|null */
+    private $stream;
+    /**
+     * @param StreamInterface|string|resource $streamOrFile
+     * @param int $size
+     * @param int $errorStatus
+     * @param string|null $clientFilename
+     * @param string|null $clientMediaType
+     */
+    public function __construct($streamOrFile, $size, $errorStatus, $clientFilename = null, $clientMediaType = null)
+    {
+        if (\false === \is_int($errorStatus) || !isset(self::ERRORS[$errorStatus])) {
+            throw new \InvalidArgumentException('Upload file error status must be an integer value and one of the "UPLOAD_ERR_*" constants');
+        }
+        if (\false === \is_int($size)) {
+            throw new \InvalidArgumentException('Upload file size must be an integer');
+        }
+        if (null !== $clientFilename && !\is_string($clientFilename)) {
+            throw new \InvalidArgumentException('Upload file client filename must be a string or null');
+        }
+        if (null !== $clientMediaType && !\is_string($clientMediaType)) {
+            throw new \InvalidArgumentException('Upload file client media type must be a string or null');
+        }
+        $this->error = $errorStatus;
+        $this->size = $size;
+        $this->clientFilename = $clientFilename;
+        $this->clientMediaType = $clientMediaType;
+        if (\UPLOAD_ERR_OK === $this->error) {
+            // Depending on the value set file or stream variable.
+            if (\is_string($streamOrFile) && '' !== $streamOrFile) {
+                $this->file = $streamOrFile;
+            } elseif (\is_resource($streamOrFile)) {
+                $this->stream = Stream::create($streamOrFile);
+            } elseif ($streamOrFile instanceof StreamInterface) {
+                $this->stream = $streamOrFile;
+            } else {
+                throw new \InvalidArgumentException('Invalid stream or file provided for UploadedFile');
+            }
+        }
+    }
+    /**
+     * @throws \RuntimeException if is moved or not ok
+     */
+    private function validateActive(): void
+    {
+        if (\UPLOAD_ERR_OK !== $this->error) {
+            throw new \RuntimeException('Cannot retrieve stream due to upload error');
+        }
+        if ($this->moved) {
+            throw new \RuntimeException('Cannot retrieve stream after it has already been moved');
+        }
+    }
+    public function getStream(): StreamInterface
+    {
+        $this->validateActive();
+        if ($this->stream instanceof StreamInterface) {
+            return $this->stream;
+        }
+        if (\false === $resource = @\fopen($this->file, 'r')) {
+            throw new \RuntimeException(\sprintf('The file "%s" cannot be opened: %s', $this->file, \error_get_last()['message'] ?? ''));
+        }
+        return Stream::create($resource);
+    }
+    public function moveTo($targetPath): void
+    {
+        $this->validateActive();
+        if (!\is_string($targetPath) || '' === $targetPath) {
+            throw new \InvalidArgumentException('Invalid path provided for move operation; must be a non-empty string');
+        }
+        if (null !== $this->file) {
+            $this->moved = 'cli' === \PHP_SAPI ? @\rename($this->file, $targetPath) : @\move_uploaded_file($this->file, $targetPath);
+            if (\false === $this->moved) {
+                throw new \RuntimeException(\sprintf('Uploaded file could not be moved to "%s": %s', $targetPath, \error_get_last()['message'] ?? ''));
+            }
+        } else {
+            $stream = $this->getStream();
+            if ($stream->isSeekable()) {
+                $stream->rewind();
+            }
+            if (\false === $resource = @\fopen($targetPath, 'w')) {
+                throw new \RuntimeException(\sprintf('The file "%s" cannot be opened: %s', $targetPath, \error_get_last()['message'] ?? ''));
+            }
+            $dest = Stream::create($resource);
+            while (!$stream->eof()) {
+                if (!$dest->write($stream->read(1048576))) {
+                    break;
+                }
+            }
+            $this->moved = \true;
+        }
+    }
+    public function getSize(): int
+    {
+        return $this->size;
+    }
+    public function getError(): int
+    {
+        return $this->error;
+    }
+    public function getClientFilename(): ?string
+    {
+        return $this->clientFilename;
+    }
+    public function getClientMediaType(): ?string
+    {
+        return $this->clientMediaType;
+    }
+}

wp-includes/php-ai-client/third-party/Nyholm/Psr7/Uri.php

@@ -0,0 +1,286 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Nyholm\Psr7;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\UriInterface;
+/**
+ * PSR-7 URI implementation.
+ *
+ * @author Michael Dowling
+ * @author Tobias Schultze
+ * @author Matthew Weier O'Phinney
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ * @author Martijn van der Ven <martijn@vanderven.se>
+ *
+ * @final This class should never be extended. See https://github.com/Nyholm/psr7/blob/master/doc/final.md
+ */
+class Uri implements UriInterface
+{
+    private const SCHEMES = ['http' => 80, 'https' => 443];
+    private const CHAR_UNRESERVED = 'a-zA-Z0-9_\-\.~';
+    private const CHAR_SUB_DELIMS = '!\$&\'\(\)\*\+,;=';
+    private const CHAR_GEN_DELIMS = ':\/\?#\[\]@';
+    /** @var string Uri scheme. */
+    private $scheme = '';
+    /** @var string Uri user info. */
+    private $userInfo = '';
+    /** @var string Uri host. */
+    private $host = '';
+    /** @var int|null Uri port. */
+    private $port;
+    /** @var string Uri path. */
+    private $path = '';
+    /** @var string Uri query string. */
+    private $query = '';
+    /** @var string Uri fragment. */
+    private $fragment = '';
+    public function __construct(string $uri = '')
+    {
+        if ('' !== $uri) {
+            if (\false === $parts = \parse_url($uri)) {
+                throw new \InvalidArgumentException(\sprintf('Unable to parse URI: "%s"', $uri));
+            }
+            // Apply parse_url parts to a URI.
+            $this->scheme = isset($parts['scheme']) ? \strtr($parts['scheme'], 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz') : '';
+            $this->userInfo = $parts['user'] ?? '';
+            $this->host = isset($parts['host']) ? \strtr($parts['host'], 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz') : '';
+            $this->port = isset($parts['port']) ? $this->filterPort($parts['port']) : null;
+            $this->path = isset($parts['path']) ? $this->filterPath($parts['path']) : '';
+            $this->query = isset($parts['query']) ? $this->filterQueryAndFragment($parts['query']) : '';
+            $this->fragment = isset($parts['fragment']) ? $this->filterQueryAndFragment($parts['fragment']) : '';
+            if (isset($parts['pass'])) {
+                $this->userInfo .= ':' . $parts['pass'];
+            }
+        }
+    }
+    public function __toString(): string
+    {
+        return self::createUriString($this->scheme, $this->getAuthority(), $this->path, $this->query, $this->fragment);
+    }
+    public function getScheme(): string
+    {
+        return $this->scheme;
+    }
+    public function getAuthority(): string
+    {
+        if ('' === $this->host) {
+            return '';
+        }
+        $authority = $this->host;
+        if ('' !== $this->userInfo) {
+            $authority = $this->userInfo . '@' . $authority;
+        }
+        if (null !== $this->port) {
+            $authority .= ':' . $this->port;
+        }
+        return $authority;
+    }
+    public function getUserInfo(): string
+    {
+        return $this->userInfo;
+    }
+    public function getHost(): string
+    {
+        return $this->host;
+    }
+    public function getPort(): ?int
+    {
+        return $this->port;
+    }
+    public function getPath(): string
+    {
+        $path = $this->path;
+        if ('' !== $path && '/' !== $path[0]) {
+            if ('' !== $this->host) {
+                // If the path is rootless and an authority is present, the path MUST be prefixed by "/"
+                $path = '/' . $path;
+            }
+        } elseif (isset($path[1]) && '/' === $path[1]) {
+            // If the path is starting with more than one "/", the
+            // starting slashes MUST be reduced to one.
+            $path = '/' . \ltrim($path, '/');
+        }
+        return $path;
+    }
+    public function getQuery(): string
+    {
+        return $this->query;
+    }
+    public function getFragment(): string
+    {
+        return $this->fragment;
+    }
+    /**
+     * @return static
+     */
+    public function withScheme($scheme): UriInterface
+    {
+        if (!\is_string($scheme)) {
+            throw new \InvalidArgumentException('Scheme must be a string');
+        }
+        if ($this->scheme === $scheme = \strtr($scheme, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->scheme = $scheme;
+        $new->port = $new->filterPort($new->port);
+        return $new;
+    }
+    /**
+     * @return static
+     */
+    public function withUserInfo($user, $password = null): UriInterface
+    {
+        if (!\is_string($user)) {
+            throw new \InvalidArgumentException('User must be a string');
+        }
+        $info = \preg_replace_callback('/[' . self::CHAR_GEN_DELIMS . self::CHAR_SUB_DELIMS . ']++/', [__CLASS__, 'rawurlencodeMatchZero'], $user);
+        if (null !== $password && '' !== $password) {
+            if (!\is_string($password)) {
+                throw new \InvalidArgumentException('Password must be a string');
+            }
+            $info .= ':' . \preg_replace_callback('/[' . self::CHAR_GEN_DELIMS . self::CHAR_SUB_DELIMS . ']++/', [__CLASS__, 'rawurlencodeMatchZero'], $password);
+        }
+        if ($this->userInfo === $info) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->userInfo = $info;
+        return $new;
+    }
+    /**
+     * @return static
+     */
+    public function withHost($host): UriInterface
+    {
+        if (!\is_string($host)) {
+            throw new \InvalidArgumentException('Host must be a string');
+        }
+        if ($this->host === $host = \strtr($host, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->host = $host;
+        return $new;
+    }
+    /**
+     * @return static
+     */
+    public function withPort($port): UriInterface
+    {
+        if ($this->port === $port = $this->filterPort($port)) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->port = $port;
+        return $new;
+    }
+    /**
+     * @return static
+     */
+    public function withPath($path): UriInterface
+    {
+        if ($this->path === $path = $this->filterPath($path)) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->path = $path;
+        return $new;
+    }
+    /**
+     * @return static
+     */
+    public function withQuery($query): UriInterface
+    {
+        if ($this->query === $query = $this->filterQueryAndFragment($query)) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->query = $query;
+        return $new;
+    }
+    /**
+     * @return static
+     */
+    public function withFragment($fragment): UriInterface
+    {
+        if ($this->fragment === $fragment = $this->filterQueryAndFragment($fragment)) {
+            return $this;
+        }
+        $new = clone $this;
+        $new->fragment = $fragment;
+        return $new;
+    }
+    /**
+     * Create a URI string from its various parts.
+     */
+    private static function createUriString(string $scheme, string $authority, string $path, string $query, string $fragment): string
+    {
+        $uri = '';
+        if ('' !== $scheme) {
+            $uri .= $scheme . ':';
+        }
+        if ('' !== $authority) {
+            $uri .= '//' . $authority;
+        }
+        if ('' !== $path) {
+            if ('/' !== $path[0]) {
+                if ('' !== $authority) {
+                    // If the path is rootless and an authority is present, the path MUST be prefixed by "/"
+                    $path = '/' . $path;
+                }
+            } elseif (isset($path[1]) && '/' === $path[1]) {
+                if ('' === $authority) {
+                    // If the path is starting with more than one "/" and no authority is present, the
+                    // starting slashes MUST be reduced to one.
+                    $path = '/' . \ltrim($path, '/');
+                }
+            }
+            $uri .= $path;
+        }
+        if ('' !== $query) {
+            $uri .= '?' . $query;
+        }
+        if ('' !== $fragment) {
+            $uri .= '#' . $fragment;
+        }
+        return $uri;
+    }
+    /**
+     * Is a given port non-standard for the current scheme?
+     */
+    private static function isNonStandardPort(string $scheme, int $port): bool
+    {
+        return !isset(self::SCHEMES[$scheme]) || $port !== self::SCHEMES[$scheme];
+    }
+    private function filterPort($port): ?int
+    {
+        if (null === $port) {
+            return null;
+        }
+        $port = (int) $port;
+        if (0 > $port || 0xffff < $port) {
+            throw new \InvalidArgumentException(\sprintf('Invalid port: %d. Must be between 0 and 65535', $port));
+        }
+        return self::isNonStandardPort($this->scheme, $port) ? $port : null;
+    }
+    private function filterPath($path): string
+    {
+        if (!\is_string($path)) {
+            throw new \InvalidArgumentException('Path must be a string');
+        }
+        return \preg_replace_callback('/(?:[^' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . '%:@\/]++|%(?![A-Fa-f0-9]{2}))/', [__CLASS__, 'rawurlencodeMatchZero'], $path);
+    }
+    private function filterQueryAndFragment($str): string
+    {
+        if (!\is_string($str)) {
+            throw new \InvalidArgumentException('Query and fragment must be a string');
+        }
+        return \preg_replace_callback('/(?:[^' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . '%:@\/\?]++|%(?![A-Fa-f0-9]{2}))/', [__CLASS__, 'rawurlencodeMatchZero'], $str);
+    }
+    private static function rawurlencodeMatchZero(array $match): string
+    {
+        return \rawurlencode($match[0]);
+    }
+}

wp-includes/php-ai-client/third-party/Psr/EventDispatcher/EventDispatcherInterface.php

@@ -0,0 +1,21 @@
+<?php
+
+declare (strict_types=1);
+namespace WordPress\AiClientDependencies\Psr\EventDispatcher;
+
+/**
+ * Defines a dispatcher for events.
+ */
+interface EventDispatcherInterface
+{
+    /**
+     * Provide all relevant listeners with an event to process.
+     *
+     * @param object $event
+     *   The object to process.
+     *
+     * @return object
+     *   The Event that was passed, now modified by listeners.
+     */
+    public function dispatch(object $event);
+}

wp-includes/php-ai-client/third-party/Psr/Http/Client/ClientExceptionInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Client;
+
+/**
+ * Every HTTP client related exception MUST implement this interface.
+ */
+interface ClientExceptionInterface extends \Throwable
+{
+}

wp-includes/php-ai-client/third-party/Psr/Http/Client/ClientInterface.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Client;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestInterface;
+use WordPress\AiClientDependencies\Psr\Http\Message\ResponseInterface;
+interface ClientInterface
+{
+    /**
+     * Sends a PSR-7 request and returns a PSR-7 response.
+     *
+     * @param RequestInterface $request
+     *
+     * @return ResponseInterface
+     *
+     * @throws \Psr\Http\Client\ClientExceptionInterface If an error happens while processing the request.
+     */
+    public function sendRequest(RequestInterface $request): ResponseInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Client/NetworkExceptionInterface.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Client;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestInterface;
+/**
+ * Thrown when the request cannot be completed because of network issues.
+ *
+ * There is no response object as this exception is thrown when no response has been received.
+ *
+ * Example: the target host name can not be resolved or the connection failed.
+ */
+interface NetworkExceptionInterface extends ClientExceptionInterface
+{
+    /**
+     * Returns the request.
+     *
+     * The request object MAY be a different object from the one passed to ClientInterface::sendRequest()
+     *
+     * @return RequestInterface
+     */
+    public function getRequest(): RequestInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Client/RequestExceptionInterface.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Client;
+
+use WordPress\AiClientDependencies\Psr\Http\Message\RequestInterface;
+/**
+ * Exception for when a request failed.
+ *
+ * Examples:
+ *      - Request is invalid (e.g. method is missing)
+ *      - Runtime request errors (e.g. the body stream is not seekable)
+ */
+interface RequestExceptionInterface extends ClientExceptionInterface
+{
+    /**
+     * Returns the request.
+     *
+     * The request object MAY be a different object from the one passed to ClientInterface::sendRequest()
+     *
+     * @return RequestInterface
+     */
+    public function getRequest(): RequestInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/MessageInterface.php

@@ -0,0 +1,177 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+/**
+ * HTTP messages consist of requests from a client to a server and responses
+ * from a server to a client. This interface defines the methods common to
+ * each.
+ *
+ * Messages are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return an instance that contains the changed state.
+ *
+ * @link http://www.ietf.org/rfc/rfc7230.txt
+ * @link http://www.ietf.org/rfc/rfc7231.txt
+ */
+interface MessageInterface
+{
+    /**
+     * Retrieves the HTTP protocol version as a string.
+     *
+     * The string MUST contain only the HTTP version number (e.g., "1.1", "1.0").
+     *
+     * @return string HTTP protocol version.
+     */
+    public function getProtocolVersion(): string;
+    /**
+     * Return an instance with the specified HTTP protocol version.
+     *
+     * The version string MUST contain only the HTTP version number (e.g.,
+     * "1.1", "1.0").
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * new protocol version.
+     *
+     * @param string $version HTTP protocol version
+     * @return static
+     */
+    public function withProtocolVersion(string $version): MessageInterface;
+    /**
+     * Retrieves all message header values.
+     *
+     * The keys represent the header name as it will be sent over the wire, and
+     * each value is an array of strings associated with the header.
+     *
+     *     // Represent the headers as a string
+     *     foreach ($message->getHeaders() as $name => $values) {
+     *         echo $name . ": " . implode(", ", $values);
+     *     }
+     *
+     *     // Emit headers iteratively:
+     *     foreach ($message->getHeaders() as $name => $values) {
+     *         foreach ($values as $value) {
+     *             header(sprintf('%s: %s', $name, $value), false);
+     *         }
+     *     }
+     *
+     * While header names are not case-sensitive, getHeaders() will preserve the
+     * exact case in which headers were originally specified.
+     *
+     * @return string[][] Returns an associative array of the message's headers. Each
+     *     key MUST be a header name, and each value MUST be an array of strings
+     *     for that header.
+     */
+    public function getHeaders(): array;
+    /**
+     * Checks if a header exists by the given case-insensitive name.
+     *
+     * @param string $name Case-insensitive header field name.
+     * @return bool Returns true if any header names match the given header
+     *     name using a case-insensitive string comparison. Returns false if
+     *     no matching header name is found in the message.
+     */
+    public function hasHeader(string $name): bool;
+    /**
+     * Retrieves a message header value by the given case-insensitive name.
+     *
+     * This method returns an array of all the header values of the given
+     * case-insensitive header name.
+     *
+     * If the header does not appear in the message, this method MUST return an
+     * empty array.
+     *
+     * @param string $name Case-insensitive header field name.
+     * @return string[] An array of string values as provided for the given
+     *    header. If the header does not appear in the message, this method MUST
+     *    return an empty array.
+     */
+    public function getHeader(string $name): array;
+    /**
+     * Retrieves a comma-separated string of the values for a single header.
+     *
+     * This method returns all of the header values of the given
+     * case-insensitive header name as a string concatenated together using
+     * a comma.
+     *
+     * NOTE: Not all header values may be appropriately represented using
+     * comma concatenation. For such headers, use getHeader() instead
+     * and supply your own delimiter when concatenating.
+     *
+     * If the header does not appear in the message, this method MUST return
+     * an empty string.
+     *
+     * @param string $name Case-insensitive header field name.
+     * @return string A string of values as provided for the given header
+     *    concatenated together using a comma. If the header does not appear in
+     *    the message, this method MUST return an empty string.
+     */
+    public function getHeaderLine(string $name): string;
+    /**
+     * Return an instance with the provided value replacing the specified header.
+     *
+     * While header names are case-insensitive, the casing of the header will
+     * be preserved by this function, and returned from getHeaders().
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * new and/or updated header and value.
+     *
+     * @param string $name Case-insensitive header field name.
+     * @param string|string[] $value Header value(s).
+     * @return static
+     * @throws \InvalidArgumentException for invalid header names or values.
+     */
+    public function withHeader(string $name, $value): MessageInterface;
+    /**
+     * Return an instance with the specified header appended with the given value.
+     *
+     * Existing values for the specified header will be maintained. The new
+     * value(s) will be appended to the existing list. If the header did not
+     * exist previously, it will be added.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * new header and/or value.
+     *
+     * @param string $name Case-insensitive header field name to add.
+     * @param string|string[] $value Header value(s).
+     * @return static
+     * @throws \InvalidArgumentException for invalid header names or values.
+     */
+    public function withAddedHeader(string $name, $value): MessageInterface;
+    /**
+     * Return an instance without the specified header.
+     *
+     * Header resolution MUST be done without case-sensitivity.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that removes
+     * the named header.
+     *
+     * @param string $name Case-insensitive header field name to remove.
+     * @return static
+     */
+    public function withoutHeader(string $name): MessageInterface;
+    /**
+     * Gets the body of the message.
+     *
+     * @return StreamInterface Returns the body as a stream.
+     */
+    public function getBody(): StreamInterface;
+    /**
+     * Return an instance with the specified message body.
+     *
+     * The body MUST be a StreamInterface object.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * new body stream.
+     *
+     * @param StreamInterface $body Body.
+     * @return static
+     * @throws \InvalidArgumentException When the body is not valid.
+     */
+    public function withBody(StreamInterface $body): MessageInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/RequestFactoryInterface.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+interface RequestFactoryInterface
+{
+    /**
+     * Create a new request.
+     *
+     * @param string $method The HTTP method associated with the request.
+     * @param UriInterface|string $uri The URI associated with the request. If
+     *     the value is a string, the factory MUST create a UriInterface
+     *     instance based on it.
+     *
+     * @return RequestInterface
+     */
+    public function createRequest(string $method, $uri): RequestInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/RequestInterface.php

@@ -0,0 +1,124 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+/**
+ * Representation of an outgoing, client-side request.
+ *
+ * Per the HTTP specification, this interface includes properties for
+ * each of the following:
+ *
+ * - Protocol version
+ * - HTTP method
+ * - URI
+ * - Headers
+ * - Message body
+ *
+ * During construction, implementations MUST attempt to set the Host header from
+ * a provided URI if no Host header is provided.
+ *
+ * Requests are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return an instance that contains the changed state.
+ */
+interface RequestInterface extends MessageInterface
+{
+    /**
+     * Retrieves the message's request target.
+     *
+     * Retrieves the message's request-target either as it will appear (for
+     * clients), as it appeared at request (for servers), or as it was
+     * specified for the instance (see withRequestTarget()).
+     *
+     * In most cases, this will be the origin-form of the composed URI,
+     * unless a value was provided to the concrete implementation (see
+     * withRequestTarget() below).
+     *
+     * If no URI is available, and no request-target has been specifically
+     * provided, this method MUST return the string "/".
+     *
+     * @return string
+     */
+    public function getRequestTarget(): string;
+    /**
+     * Return an instance with the specific request-target.
+     *
+     * If the request needs a non-origin-form request-target — e.g., for
+     * specifying an absolute-form, authority-form, or asterisk-form —
+     * this method may be used to create an instance with the specified
+     * request-target, verbatim.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * changed request target.
+     *
+     * @link http://tools.ietf.org/html/rfc7230#section-5.3 (for the various
+     *     request-target forms allowed in request messages)
+     * @param string $requestTarget
+     * @return static
+     */
+    public function withRequestTarget(string $requestTarget): RequestInterface;
+    /**
+     * Retrieves the HTTP method of the request.
+     *
+     * @return string Returns the request method.
+     */
+    public function getMethod(): string;
+    /**
+     * Return an instance with the provided HTTP method.
+     *
+     * While HTTP method names are typically all uppercase characters, HTTP
+     * method names are case-sensitive and thus implementations SHOULD NOT
+     * modify the given string.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * changed request method.
+     *
+     * @param string $method Case-sensitive method.
+     * @return static
+     * @throws \InvalidArgumentException for invalid HTTP methods.
+     */
+    public function withMethod(string $method): RequestInterface;
+    /**
+     * Retrieves the URI instance.
+     *
+     * This method MUST return a UriInterface instance.
+     *
+     * @link http://tools.ietf.org/html/rfc3986#section-4.3
+     * @return UriInterface Returns a UriInterface instance
+     *     representing the URI of the request.
+     */
+    public function getUri(): UriInterface;
+    /**
+     * Returns an instance with the provided URI.
+     *
+     * This method MUST update the Host header of the returned request by
+     * default if the URI contains a host component. If the URI does not
+     * contain a host component, any pre-existing Host header MUST be carried
+     * over to the returned request.
+     *
+     * You can opt-in to preserving the original state of the Host header by
+     * setting `$preserveHost` to `true`. When `$preserveHost` is set to
+     * `true`, this method interacts with the Host header in the following ways:
+     *
+     * - If the Host header is missing or empty, and the new URI contains
+     *   a host component, this method MUST update the Host header in the returned
+     *   request.
+     * - If the Host header is missing or empty, and the new URI does not contain a
+     *   host component, this method MUST NOT update the Host header in the returned
+     *   request.
+     * - If a Host header is present and non-empty, this method MUST NOT update
+     *   the Host header in the returned request.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * new UriInterface instance.
+     *
+     * @link http://tools.ietf.org/html/rfc3986#section-4.3
+     * @param UriInterface $uri New request URI to use.
+     * @param bool $preserveHost Preserve the original state of the Host header.
+     * @return static
+     */
+    public function withUri(UriInterface $uri, bool $preserveHost = \false): RequestInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/ResponseFactoryInterface.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+interface ResponseFactoryInterface
+{
+    /**
+     * Create a new response.
+     *
+     * @param int $code HTTP status code; defaults to 200
+     * @param string $reasonPhrase Reason phrase to associate with status code
+     *     in generated response; if none is provided implementations MAY use
+     *     the defaults as suggested in the HTTP specification.
+     *
+     * @return ResponseInterface
+     */
+    public function createResponse(int $code = 200, string $reasonPhrase = ''): ResponseInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/ResponseInterface.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+/**
+ * Representation of an outgoing, server-side response.
+ *
+ * Per the HTTP specification, this interface includes properties for
+ * each of the following:
+ *
+ * - Protocol version
+ * - Status code and reason phrase
+ * - Headers
+ * - Message body
+ *
+ * Responses are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return an instance that contains the changed state.
+ */
+interface ResponseInterface extends MessageInterface
+{
+    /**
+     * Gets the response status code.
+     *
+     * The status code is a 3-digit integer result code of the server's attempt
+     * to understand and satisfy the request.
+     *
+     * @return int Status code.
+     */
+    public function getStatusCode(): int;
+    /**
+     * Return an instance with the specified status code and, optionally, reason phrase.
+     *
+     * If no reason phrase is specified, implementations MAY choose to default
+     * to the RFC 7231 or IANA recommended reason phrase for the response's
+     * status code.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated status and reason phrase.
+     *
+     * @link http://tools.ietf.org/html/rfc7231#section-6
+     * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+     * @param int $code The 3-digit integer result code to set.
+     * @param string $reasonPhrase The reason phrase to use with the
+     *     provided status code; if none is provided, implementations MAY
+     *     use the defaults as suggested in the HTTP specification.
+     * @return static
+     * @throws \InvalidArgumentException For invalid status code arguments.
+     */
+    public function withStatus(int $code, string $reasonPhrase = ''): ResponseInterface;
+    /**
+     * Gets the response reason phrase associated with the status code.
+     *
+     * Because a reason phrase is not a required element in a response
+     * status line, the reason phrase value MAY be null. Implementations MAY
+     * choose to return the default RFC 7231 recommended reason phrase (or those
+     * listed in the IANA HTTP Status Code Registry) for the response's
+     * status code.
+     *
+     * @link http://tools.ietf.org/html/rfc7231#section-6
+     * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+     * @return string Reason phrase; must return an empty string if none present.
+     */
+    public function getReasonPhrase(): string;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/ServerRequestFactoryInterface.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+interface ServerRequestFactoryInterface
+{
+    /**
+     * Create a new server request.
+     *
+     * Note that server-params are taken precisely as given - no parsing/processing
+     * of the given values is performed, and, in particular, no attempt is made to
+     * determine the HTTP method or URI, which must be provided explicitly.
+     *
+     * @param string $method The HTTP method associated with the request.
+     * @param UriInterface|string $uri The URI associated with the request. If
+     *     the value is a string, the factory MUST create a UriInterface
+     *     instance based on it.
+     * @param array $serverParams Array of SAPI parameters with which to seed
+     *     the generated request instance.
+     *
+     * @return ServerRequestInterface
+     */
+    public function createServerRequest(string $method, $uri, array $serverParams = []): ServerRequestInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/ServerRequestInterface.php

@@ -0,0 +1,249 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+/**
+ * Representation of an incoming, server-side HTTP request.
+ *
+ * Per the HTTP specification, this interface includes properties for
+ * each of the following:
+ *
+ * - Protocol version
+ * - HTTP method
+ * - URI
+ * - Headers
+ * - Message body
+ *
+ * Additionally, it encapsulates all data as it has arrived to the
+ * application from the CGI and/or PHP environment, including:
+ *
+ * - The values represented in $_SERVER.
+ * - Any cookies provided (generally via $_COOKIE)
+ * - Query string arguments (generally via $_GET, or as parsed via parse_str())
+ * - Upload files, if any (as represented by $_FILES)
+ * - Deserialized body parameters (generally from $_POST)
+ *
+ * $_SERVER values MUST be treated as immutable, as they represent application
+ * state at the time of request; as such, no methods are provided to allow
+ * modification of those values. The other values provide such methods, as they
+ * can be restored from $_SERVER or the request body, and may need treatment
+ * during the application (e.g., body parameters may be deserialized based on
+ * content type).
+ *
+ * Additionally, this interface recognizes the utility of introspecting a
+ * request to derive and match additional parameters (e.g., via URI path
+ * matching, decrypting cookie values, deserializing non-form-encoded body
+ * content, matching authorization headers to users, etc). These parameters
+ * are stored in an "attributes" property.
+ *
+ * Requests are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return an instance that contains the changed state.
+ */
+interface ServerRequestInterface extends RequestInterface
+{
+    /**
+     * Retrieve server parameters.
+     *
+     * Retrieves data related to the incoming request environment,
+     * typically derived from PHP's $_SERVER superglobal. The data IS NOT
+     * REQUIRED to originate from $_SERVER.
+     *
+     * @return array
+     */
+    public function getServerParams(): array;
+    /**
+     * Retrieve cookies.
+     *
+     * Retrieves cookies sent by the client to the server.
+     *
+     * The data MUST be compatible with the structure of the $_COOKIE
+     * superglobal.
+     *
+     * @return array
+     */
+    public function getCookieParams(): array;
+    /**
+     * Return an instance with the specified cookies.
+     *
+     * The data IS NOT REQUIRED to come from the $_COOKIE superglobal, but MUST
+     * be compatible with the structure of $_COOKIE. Typically, this data will
+     * be injected at instantiation.
+     *
+     * This method MUST NOT update the related Cookie header of the request
+     * instance, nor related values in the server params.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated cookie values.
+     *
+     * @param array $cookies Array of key/value pairs representing cookies.
+     * @return static
+     */
+    public function withCookieParams(array $cookies): ServerRequestInterface;
+    /**
+     * Retrieve query string arguments.
+     *
+     * Retrieves the deserialized query string arguments, if any.
+     *
+     * Note: the query params might not be in sync with the URI or server
+     * params. If you need to ensure you are only getting the original
+     * values, you may need to parse the query string from `getUri()->getQuery()`
+     * or from the `QUERY_STRING` server param.
+     *
+     * @return array
+     */
+    public function getQueryParams(): array;
+    /**
+     * Return an instance with the specified query string arguments.
+     *
+     * These values SHOULD remain immutable over the course of the incoming
+     * request. They MAY be injected during instantiation, such as from PHP's
+     * $_GET superglobal, or MAY be derived from some other value such as the
+     * URI. In cases where the arguments are parsed from the URI, the data
+     * MUST be compatible with what PHP's parse_str() would return for
+     * purposes of how duplicate query parameters are handled, and how nested
+     * sets are handled.
+     *
+     * Setting query string arguments MUST NOT change the URI stored by the
+     * request, nor the values in the server params.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated query string arguments.
+     *
+     * @param array $query Array of query string arguments, typically from
+     *     $_GET.
+     * @return static
+     */
+    public function withQueryParams(array $query): ServerRequestInterface;
+    /**
+     * Retrieve normalized file upload data.
+     *
+     * This method returns upload metadata in a normalized tree, with each leaf
+     * an instance of Psr\Http\Message\UploadedFileInterface.
+     *
+     * These values MAY be prepared from $_FILES or the message body during
+     * instantiation, or MAY be injected via withUploadedFiles().
+     *
+     * @return array An array tree of UploadedFileInterface instances; an empty
+     *     array MUST be returned if no data is present.
+     */
+    public function getUploadedFiles(): array;
+    /**
+     * Create a new instance with the specified uploaded files.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated body parameters.
+     *
+     * @param array $uploadedFiles An array tree of UploadedFileInterface instances.
+     * @return static
+     * @throws \InvalidArgumentException if an invalid structure is provided.
+     */
+    public function withUploadedFiles(array $uploadedFiles): ServerRequestInterface;
+    /**
+     * Retrieve any parameters provided in the request body.
+     *
+     * If the request Content-Type is either application/x-www-form-urlencoded
+     * or multipart/form-data, and the request method is POST, this method MUST
+     * return the contents of $_POST.
+     *
+     * Otherwise, this method may return any results of deserializing
+     * the request body content; as parsing returns structured content, the
+     * potential types MUST be arrays or objects only. A null value indicates
+     * the absence of body content.
+     *
+     * @return null|array|object The deserialized body parameters, if any.
+     *     These will typically be an array or object.
+     */
+    public function getParsedBody();
+    /**
+     * Return an instance with the specified body parameters.
+     *
+     * These MAY be injected during instantiation.
+     *
+     * If the request Content-Type is either application/x-www-form-urlencoded
+     * or multipart/form-data, and the request method is POST, use this method
+     * ONLY to inject the contents of $_POST.
+     *
+     * The data IS NOT REQUIRED to come from $_POST, but MUST be the results of
+     * deserializing the request body content. Deserialization/parsing returns
+     * structured data, and, as such, this method ONLY accepts arrays or objects,
+     * or a null value if nothing was available to parse.
+     *
+     * As an example, if content negotiation determines that the request data
+     * is a JSON payload, this method could be used to create a request
+     * instance with the deserialized parameters.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated body parameters.
+     *
+     * @param null|array|object $data The deserialized body data. This will
+     *     typically be in an array or object.
+     * @return static
+     * @throws \InvalidArgumentException if an unsupported argument type is
+     *     provided.
+     */
+    public function withParsedBody($data): ServerRequestInterface;
+    /**
+     * Retrieve attributes derived from the request.
+     *
+     * The request "attributes" may be used to allow injection of any
+     * parameters derived from the request: e.g., the results of path
+     * match operations; the results of decrypting cookies; the results of
+     * deserializing non-form-encoded message bodies; etc. Attributes
+     * will be application and request specific, and CAN be mutable.
+     *
+     * @return array Attributes derived from the request.
+     */
+    public function getAttributes(): array;
+    /**
+     * Retrieve a single derived request attribute.
+     *
+     * Retrieves a single derived request attribute as described in
+     * getAttributes(). If the attribute has not been previously set, returns
+     * the default value as provided.
+     *
+     * This method obviates the need for a hasAttribute() method, as it allows
+     * specifying a default value to return if the attribute is not found.
+     *
+     * @see getAttributes()
+     * @param string $name The attribute name.
+     * @param mixed $default Default value to return if the attribute does not exist.
+     * @return mixed
+     */
+    public function getAttribute(string $name, $default = null);
+    /**
+     * Return an instance with the specified derived request attribute.
+     *
+     * This method allows setting a single derived request attribute as
+     * described in getAttributes().
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated attribute.
+     *
+     * @see getAttributes()
+     * @param string $name The attribute name.
+     * @param mixed $value The value of the attribute.
+     * @return static
+     */
+    public function withAttribute(string $name, $value): ServerRequestInterface;
+    /**
+     * Return an instance that removes the specified derived request attribute.
+     *
+     * This method allows removing a single derived request attribute as
+     * described in getAttributes().
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that removes
+     * the attribute.
+     *
+     * @see getAttributes()
+     * @param string $name The attribute name.
+     * @return static
+     */
+    public function withoutAttribute(string $name): ServerRequestInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/StreamFactoryInterface.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+interface StreamFactoryInterface
+{
+    /**
+     * Create a new stream from a string.
+     *
+     * The stream SHOULD be created with a temporary resource.
+     *
+     * @param string $content String content with which to populate the stream.
+     *
+     * @return StreamInterface
+     */
+    public function createStream(string $content = ''): StreamInterface;
+    /**
+     * Create a stream from an existing file.
+     *
+     * The file MUST be opened using the given mode, which may be any mode
+     * supported by the `fopen` function.
+     *
+     * The `$filename` MAY be any string supported by `fopen()`.
+     *
+     * @param string $filename Filename or stream URI to use as basis of stream.
+     * @param string $mode Mode with which to open the underlying filename/stream.
+     *
+     * @return StreamInterface
+     * @throws \RuntimeException If the file cannot be opened.
+     * @throws \InvalidArgumentException If the mode is invalid.
+     */
+    public function createStreamFromFile(string $filename, string $mode = 'r'): StreamInterface;
+    /**
+     * Create a new stream from an existing resource.
+     *
+     * The stream MUST be readable and may be writable.
+     *
+     * @param resource $resource PHP resource to use as basis of stream.
+     *
+     * @return StreamInterface
+     */
+    public function createStreamFromResource($resource): StreamInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/StreamInterface.php

@@ -0,0 +1,144 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+/**
+ * Describes a data stream.
+ *
+ * Typically, an instance will wrap a PHP stream; this interface provides
+ * a wrapper around the most common operations, including serialization of
+ * the entire stream to a string.
+ */
+interface StreamInterface
+{
+    /**
+     * Reads all data from the stream into a string, from the beginning to end.
+     *
+     * This method MUST attempt to seek to the beginning of the stream before
+     * reading data and read the stream until the end is reached.
+     *
+     * Warning: This could attempt to load a large amount of data into memory.
+     *
+     * This method MUST NOT raise an exception in order to conform with PHP's
+     * string casting operations.
+     *
+     * @see http://php.net/manual/en/language.oop5.magic.php#object.tostring
+     * @return string
+     */
+    public function __toString(): string;
+    /**
+     * Closes the stream and any underlying resources.
+     *
+     * @return void
+     */
+    public function close(): void;
+    /**
+     * Separates any underlying resources from the stream.
+     *
+     * After the stream has been detached, the stream is in an unusable state.
+     *
+     * @return resource|null Underlying PHP stream, if any
+     */
+    public function detach();
+    /**
+     * Get the size of the stream if known.
+     *
+     * @return int|null Returns the size in bytes if known, or null if unknown.
+     */
+    public function getSize(): ?int;
+    /**
+     * Returns the current position of the file read/write pointer
+     *
+     * @return int Position of the file pointer
+     * @throws \RuntimeException on error.
+     */
+    public function tell(): int;
+    /**
+     * Returns true if the stream is at the end of the stream.
+     *
+     * @return bool
+     */
+    public function eof(): bool;
+    /**
+     * Returns whether or not the stream is seekable.
+     *
+     * @return bool
+     */
+    public function isSeekable(): bool;
+    /**
+     * Seek to a position in the stream.
+     *
+     * @link http://www.php.net/manual/en/function.fseek.php
+     * @param int $offset Stream offset
+     * @param int $whence Specifies how the cursor position will be calculated
+     *     based on the seek offset. Valid values are identical to the built-in
+     *     PHP $whence values for `fseek()`.  SEEK_SET: Set position equal to
+     *     offset bytes SEEK_CUR: Set position to current location plus offset
+     *     SEEK_END: Set position to end-of-stream plus offset.
+     * @throws \RuntimeException on failure.
+     */
+    public function seek(int $offset, int $whence = \SEEK_SET): void;
+    /**
+     * Seek to the beginning of the stream.
+     *
+     * If the stream is not seekable, this method will raise an exception;
+     * otherwise, it will perform a seek(0).
+     *
+     * @see seek()
+     * @link http://www.php.net/manual/en/function.fseek.php
+     * @throws \RuntimeException on failure.
+     */
+    public function rewind(): void;
+    /**
+     * Returns whether or not the stream is writable.
+     *
+     * @return bool
+     */
+    public function isWritable(): bool;
+    /**
+     * Write data to the stream.
+     *
+     * @param string $string The string that is to be written.
+     * @return int Returns the number of bytes written to the stream.
+     * @throws \RuntimeException on failure.
+     */
+    public function write(string $string): int;
+    /**
+     * Returns whether or not the stream is readable.
+     *
+     * @return bool
+     */
+    public function isReadable(): bool;
+    /**
+     * Read data from the stream.
+     *
+     * @param int $length Read up to $length bytes from the object and return
+     *     them. Fewer than $length bytes may be returned if underlying stream
+     *     call returns fewer bytes.
+     * @return string Returns the data read from the stream, or an empty string
+     *     if no bytes are available.
+     * @throws \RuntimeException if an error occurs.
+     */
+    public function read(int $length): string;
+    /**
+     * Returns the remaining contents in a string
+     *
+     * @return string
+     * @throws \RuntimeException if unable to read or an error occurs while
+     *     reading.
+     */
+    public function getContents(): string;
+    /**
+     * Get stream metadata as an associative array or retrieve a specific key.
+     *
+     * The keys returned are identical to the keys returned from PHP's
+     * stream_get_meta_data() function.
+     *
+     * @link http://php.net/manual/en/function.stream-get-meta-data.php
+     * @param string|null $key Specific metadata to retrieve.
+     * @return array|mixed|null Returns an associative array if no key is
+     *     provided. Returns a specific key value if a key is provided and the
+     *     value is found, or null if the key is not found.
+     */
+    public function getMetadata(?string $key = null);
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/UploadedFileFactoryInterface.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+interface UploadedFileFactoryInterface
+{
+    /**
+     * Create a new uploaded file.
+     *
+     * If a size is not provided it will be determined by checking the size of
+     * the file.
+     *
+     * @see http://php.net/manual/features.file-upload.post-method.php
+     * @see http://php.net/manual/features.file-upload.errors.php
+     *
+     * @param StreamInterface $stream Underlying stream representing the
+     *     uploaded file content.
+     * @param int|null $size in bytes
+     * @param int $error PHP file upload error
+     * @param string|null $clientFilename Filename as provided by the client, if any.
+     * @param string|null $clientMediaType Media type as provided by the client, if any.
+     *
+     * @return UploadedFileInterface
+     *
+     * @throws \InvalidArgumentException If the file resource is not readable.
+     */
+    public function createUploadedFile(StreamInterface $stream, ?int $size = null, int $error = \UPLOAD_ERR_OK, ?string $clientFilename = null, ?string $clientMediaType = null): UploadedFileInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/UploadedFileInterface.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+/**
+ * Value object representing a file uploaded through an HTTP request.
+ *
+ * Instances of this interface are considered immutable; all methods that
+ * might change state MUST be implemented such that they retain the internal
+ * state of the current instance and return an instance that contains the
+ * changed state.
+ */
+interface UploadedFileInterface
+{
+    /**
+     * Retrieve a stream representing the uploaded file.
+     *
+     * This method MUST return a StreamInterface instance, representing the
+     * uploaded file. The purpose of this method is to allow utilizing native PHP
+     * stream functionality to manipulate the file upload, such as
+     * stream_copy_to_stream() (though the result will need to be decorated in a
+     * native PHP stream wrapper to work with such functions).
+     *
+     * If the moveTo() method has been called previously, this method MUST raise
+     * an exception.
+     *
+     * @return StreamInterface Stream representation of the uploaded file.
+     * @throws \RuntimeException in cases when no stream is available or can be
+     *     created.
+     */
+    public function getStream(): StreamInterface;
+    /**
+     * Move the uploaded file to a new location.
+     *
+     * Use this method as an alternative to move_uploaded_file(). This method is
+     * guaranteed to work in both SAPI and non-SAPI environments.
+     * Implementations must determine which environment they are in, and use the
+     * appropriate method (move_uploaded_file(), rename(), or a stream
+     * operation) to perform the operation.
+     *
+     * $targetPath may be an absolute path, or a relative path. If it is a
+     * relative path, resolution should be the same as used by PHP's rename()
+     * function.
+     *
+     * The original file or stream MUST be removed on completion.
+     *
+     * If this method is called more than once, any subsequent calls MUST raise
+     * an exception.
+     *
+     * When used in an SAPI environment where $_FILES is populated, when writing
+     * files via moveTo(), is_uploaded_file() and move_uploaded_file() SHOULD be
+     * used to ensure permissions and upload status are verified correctly.
+     *
+     * If you wish to move to a stream, use getStream(), as SAPI operations
+     * cannot guarantee writing to stream destinations.
+     *
+     * @see http://php.net/is_uploaded_file
+     * @see http://php.net/move_uploaded_file
+     * @param string $targetPath Path to which to move the uploaded file.
+     * @throws \InvalidArgumentException if the $targetPath specified is invalid.
+     * @throws \RuntimeException on any error during the move operation, or on
+     *     the second or subsequent call to the method.
+     */
+    public function moveTo(string $targetPath): void;
+    /**
+     * Retrieve the file size.
+     *
+     * Implementations SHOULD return the value stored in the "size" key of
+     * the file in the $_FILES array if available, as PHP calculates this based
+     * on the actual size transmitted.
+     *
+     * @return int|null The file size in bytes or null if unknown.
+     */
+    public function getSize(): ?int;
+    /**
+     * Retrieve the error associated with the uploaded file.
+     *
+     * The return value MUST be one of PHP's UPLOAD_ERR_XXX constants.
+     *
+     * If the file was uploaded successfully, this method MUST return
+     * UPLOAD_ERR_OK.
+     *
+     * Implementations SHOULD return the value stored in the "error" key of
+     * the file in the $_FILES array.
+     *
+     * @see http://php.net/manual/en/features.file-upload.errors.php
+     * @return int One of PHP's UPLOAD_ERR_XXX constants.
+     */
+    public function getError(): int;
+    /**
+     * Retrieve the filename sent by the client.
+     *
+     * Do not trust the value returned by this method. A client could send
+     * a malicious filename with the intention to corrupt or hack your
+     * application.
+     *
+     * Implementations SHOULD return the value stored in the "name" key of
+     * the file in the $_FILES array.
+     *
+     * @return string|null The filename sent by the client or null if none
+     *     was provided.
+     */
+    public function getClientFilename(): ?string;
+    /**
+     * Retrieve the media type sent by the client.
+     *
+     * Do not trust the value returned by this method. A client could send
+     * a malicious media type with the intention to corrupt or hack your
+     * application.
+     *
+     * Implementations SHOULD return the value stored in the "type" key of
+     * the file in the $_FILES array.
+     *
+     * @return string|null The media type sent by the client or null if none
+     *     was provided.
+     */
+    public function getClientMediaType(): ?string;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/UriFactoryInterface.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+interface UriFactoryInterface
+{
+    /**
+     * Create a new URI.
+     *
+     * @param string $uri
+     *
+     * @return UriInterface
+     *
+     * @throws \InvalidArgumentException If the given URI cannot be parsed.
+     */
+    public function createUri(string $uri = ''): UriInterface;
+}

wp-includes/php-ai-client/third-party/Psr/Http/Message/UriInterface.php

@@ -0,0 +1,309 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\Http\Message;
+
+/**
+ * Value object representing a URI.
+ *
+ * This interface is meant to represent URIs according to RFC 3986 and to
+ * provide methods for most common operations. Additional functionality for
+ * working with URIs can be provided on top of the interface or externally.
+ * Its primary use is for HTTP requests, but may also be used in other
+ * contexts.
+ *
+ * Instances of this interface are considered immutable; all methods that
+ * might change state MUST be implemented such that they retain the internal
+ * state of the current instance and return an instance that contains the
+ * changed state.
+ *
+ * Typically the Host header will be also be present in the request message.
+ * For server-side requests, the scheme will typically be discoverable in the
+ * server parameters.
+ *
+ * @link http://tools.ietf.org/html/rfc3986 (the URI specification)
+ */
+interface UriInterface
+{
+    /**
+     * Retrieve the scheme component of the URI.
+     *
+     * If no scheme is present, this method MUST return an empty string.
+     *
+     * The value returned MUST be normalized to lowercase, per RFC 3986
+     * Section 3.1.
+     *
+     * The trailing ":" character is not part of the scheme and MUST NOT be
+     * added.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-3.1
+     * @return string The URI scheme.
+     */
+    public function getScheme(): string;
+    /**
+     * Retrieve the authority component of the URI.
+     *
+     * If no authority information is present, this method MUST return an empty
+     * string.
+     *
+     * The authority syntax of the URI is:
+     *
+     * <pre>
+     * [user-info@]host[:port]
+     * </pre>
+     *
+     * If the port component is not set or is the standard port for the current
+     * scheme, it SHOULD NOT be included.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-3.2
+     * @return string The URI authority, in "[user-info@]host[:port]" format.
+     */
+    public function getAuthority(): string;
+    /**
+     * Retrieve the user information component of the URI.
+     *
+     * If no user information is present, this method MUST return an empty
+     * string.
+     *
+     * If a user is present in the URI, this will return that value;
+     * additionally, if the password is also present, it will be appended to the
+     * user value, with a colon (":") separating the values.
+     *
+     * The trailing "@" character is not part of the user information and MUST
+     * NOT be added.
+     *
+     * @return string The URI user information, in "username[:password]" format.
+     */
+    public function getUserInfo(): string;
+    /**
+     * Retrieve the host component of the URI.
+     *
+     * If no host is present, this method MUST return an empty string.
+     *
+     * The value returned MUST be normalized to lowercase, per RFC 3986
+     * Section 3.2.2.
+     *
+     * @see http://tools.ietf.org/html/rfc3986#section-3.2.2
+     * @return string The URI host.
+     */
+    public function getHost(): string;
+    /**
+     * Retrieve the port component of the URI.
+     *
+     * If a port is present, and it is non-standard for the current scheme,
+     * this method MUST return it as an integer. If the port is the standard port
+     * used with the current scheme, this method SHOULD return null.
+     *
+     * If no port is present, and no scheme is present, this method MUST return
+     * a null value.
+     *
+     * If no port is present, but a scheme is present, this method MAY return
+     * the standard port for that scheme, but SHOULD return null.
+     *
+     * @return null|int The URI port.
+     */
+    public function getPort(): ?int;
+    /**
+     * Retrieve the path component of the URI.
+     *
+     * The path can either be empty or absolute (starting with a slash) or
+     * rootless (not starting with a slash). Implementations MUST support all
+     * three syntaxes.
+     *
+     * Normally, the empty path "" and absolute path "/" are considered equal as
+     * defined in RFC 7230 Section 2.7.3. But this method MUST NOT automatically
+     * do this normalization because in contexts with a trimmed base path, e.g.
+     * the front controller, this difference becomes significant. It's the task
+     * of the user to handle both "" and "/".
+     *
+     * The value returned MUST be percent-encoded, but MUST NOT double-encode
+     * any characters. To determine what characters to encode, please refer to
+     * RFC 3986, Sections 2 and 3.3.
+     *
+     * As an example, if the value should include a slash ("/") not intended as
+     * delimiter between path segments, that value MUST be passed in encoded
+     * form (e.g., "%2F") to the instance.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-2
+     * @see https://tools.ietf.org/html/rfc3986#section-3.3
+     * @return string The URI path.
+     */
+    public function getPath(): string;
+    /**
+     * Retrieve the query string of the URI.
+     *
+     * If no query string is present, this method MUST return an empty string.
+     *
+     * The leading "?" character is not part of the query and MUST NOT be
+     * added.
+     *
+     * The value returned MUST be percent-encoded, but MUST NOT double-encode
+     * any characters. To determine what characters to encode, please refer to
+     * RFC 3986, Sections 2 and 3.4.
+     *
+     * As an example, if a value in a key/value pair of the query string should
+     * include an ampersand ("&") not intended as a delimiter between values,
+     * that value MUST be passed in encoded form (e.g., "%26") to the instance.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-2
+     * @see https://tools.ietf.org/html/rfc3986#section-3.4
+     * @return string The URI query string.
+     */
+    public function getQuery(): string;
+    /**
+     * Retrieve the fragment component of the URI.
+     *
+     * If no fragment is present, this method MUST return an empty string.
+     *
+     * The leading "#" character is not part of the fragment and MUST NOT be
+     * added.
+     *
+     * The value returned MUST be percent-encoded, but MUST NOT double-encode
+     * any characters. To determine what characters to encode, please refer to
+     * RFC 3986, Sections 2 and 3.5.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-2
+     * @see https://tools.ietf.org/html/rfc3986#section-3.5
+     * @return string The URI fragment.
+     */
+    public function getFragment(): string;
+    /**
+     * Return an instance with the specified scheme.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified scheme.
+     *
+     * Implementations MUST support the schemes "http" and "https" case
+     * insensitively, and MAY accommodate other schemes if required.
+     *
+     * An empty scheme is equivalent to removing the scheme.
+     *
+     * @param string $scheme The scheme to use with the new instance.
+     * @return static A new instance with the specified scheme.
+     * @throws \InvalidArgumentException for invalid or unsupported schemes.
+     */
+    public function withScheme(string $scheme): UriInterface;
+    /**
+     * Return an instance with the specified user information.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified user information.
+     *
+     * Password is optional, but the user information MUST include the
+     * user; an empty string for the user is equivalent to removing user
+     * information.
+     *
+     * @param string $user The user name to use for authority.
+     * @param null|string $password The password associated with $user.
+     * @return static A new instance with the specified user information.
+     */
+    public function withUserInfo(string $user, ?string $password = null): UriInterface;
+    /**
+     * Return an instance with the specified host.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified host.
+     *
+     * An empty host value is equivalent to removing the host.
+     *
+     * @param string $host The hostname to use with the new instance.
+     * @return static A new instance with the specified host.
+     * @throws \InvalidArgumentException for invalid hostnames.
+     */
+    public function withHost(string $host): UriInterface;
+    /**
+     * Return an instance with the specified port.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified port.
+     *
+     * Implementations MUST raise an exception for ports outside the
+     * established TCP and UDP port ranges.
+     *
+     * A null value provided for the port is equivalent to removing the port
+     * information.
+     *
+     * @param null|int $port The port to use with the new instance; a null value
+     *     removes the port information.
+     * @return static A new instance with the specified port.
+     * @throws \InvalidArgumentException for invalid ports.
+     */
+    public function withPort(?int $port): UriInterface;
+    /**
+     * Return an instance with the specified path.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified path.
+     *
+     * The path can either be empty or absolute (starting with a slash) or
+     * rootless (not starting with a slash). Implementations MUST support all
+     * three syntaxes.
+     *
+     * If the path is intended to be domain-relative rather than path relative then
+     * it must begin with a slash ("/"). Paths not starting with a slash ("/")
+     * are assumed to be relative to some base path known to the application or
+     * consumer.
+     *
+     * Users can provide both encoded and decoded path characters.
+     * Implementations ensure the correct encoding as outlined in getPath().
+     *
+     * @param string $path The path to use with the new instance.
+     * @return static A new instance with the specified path.
+     * @throws \InvalidArgumentException for invalid paths.
+     */
+    public function withPath(string $path): UriInterface;
+    /**
+     * Return an instance with the specified query string.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified query string.
+     *
+     * Users can provide both encoded and decoded query characters.
+     * Implementations ensure the correct encoding as outlined in getQuery().
+     *
+     * An empty query string value is equivalent to removing the query string.
+     *
+     * @param string $query The query string to use with the new instance.
+     * @return static A new instance with the specified query string.
+     * @throws \InvalidArgumentException for invalid query strings.
+     */
+    public function withQuery(string $query): UriInterface;
+    /**
+     * Return an instance with the specified URI fragment.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified URI fragment.
+     *
+     * Users can provide both encoded and decoded fragment characters.
+     * Implementations ensure the correct encoding as outlined in getFragment().
+     *
+     * An empty fragment value is equivalent to removing the fragment.
+     *
+     * @param string $fragment The fragment to use with the new instance.
+     * @return static A new instance with the specified fragment.
+     */
+    public function withFragment(string $fragment): UriInterface;
+    /**
+     * Return the string representation as a URI reference.
+     *
+     * Depending on which components of the URI are present, the resulting
+     * string is either a full URI or relative reference according to RFC 3986,
+     * Section 4.1. The method concatenates the various components of the URI,
+     * using the appropriate delimiters:
+     *
+     * - If a scheme is present, it MUST be suffixed by ":".
+     * - If an authority is present, it MUST be prefixed by "//".
+     * - The path can be concatenated without delimiters. But there are two
+     *   cases where the path has to be adjusted to make the URI reference
+     *   valid as PHP does not allow to throw an exception in __toString():
+     *     - If the path is rootless and an authority is present, the path MUST
+     *       be prefixed by "/".
+     *     - If the path is starting with more than one "/" and no authority is
+     *       present, the starting slashes MUST be reduced to one.
+     * - If a query is present, it MUST be prefixed by "?".
+     * - If a fragment is present, it MUST be prefixed by "#".
+     *
+     * @see http://tools.ietf.org/html/rfc3986#section-4.1
+     * @return string
+     */
+    public function __toString(): string;
+}

wp-includes/php-ai-client/third-party/Psr/SimpleCache/CacheInterface.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace WordPress\AiClientDependencies\Psr\SimpleCache;
+
+interface CacheInterface
+{
+    /**
+     * Fetches a value from the cache.
+     *
+     * @param string $key     The unique key of this item in the cache.
+     * @param mixed  $default Default value to return if the key does not exist.
+     *
+     * @return mixed The value of the item from the cache, or $default in case of cache miss.
+     *
+     * @throws \Psr\SimpleCache\InvalidArgumentException
+     *   MUST be thrown if the $key string is not a legal value.
+     */
+    public function get($key, $default = null);
+    /**
+     * Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time.
+     *
+     * @param string                 $key   The key of the item to store.
+     * @param mixed                  $value The value of the item to store, must be serializable.
+     * @param null|int|\DateInterval $ttl   Optional. The TTL value of this item. If no value is sent and
+     *                                      the driver supports TTL then the library may set a default value
+     *                                      for it or let the driver take care of that.
+     *
+     * @return bool True on success and false on failure.
+     *
+     * @throws \Psr\SimpleCache\InvalidArgumentException
+     *   MUST be thrown if the $key string is not a legal value.
+     */
+    public function set($key, $value, $ttl = null);
+    /**
+     * Delete an item from the cache by its unique key.
+     *
+     * @param string $key The unique cache key of the item to delete.
+     *
+     * @return bool True if the item was successfully removed. False if there was an error.
+     *
+     * @throws \Psr\SimpleCache\InvalidArgumentException
+     *   MUST be thrown if the $key string is not a legal value.
+     */
+    public function delete($key);
+    /**
+     * Wipes clean the entire cache's keys.
+     *
+     * @return bool True on success and false on failure.
+     */
+    public function clear();
+    /**
+     * Obtains multiple cache items by their unique keys.
+     *
+     * @param iterable $keys    A list of keys that can obtained in a single operation.
+     * @param mixed    $default Default value to return for keys that do not exist.
+     *
+     * @return iterable A list of key => value pairs. Cache keys that do not exist or are stale will have $default as value.
+     *
+     * @throws \Psr\SimpleCache\InvalidArgumentException
+     *   MUST be thrown if $keys is neither an array nor a Traversable,
+     *   or if any of the $keys are not a legal value.
+     */
+    public function getMultiple($keys, $default = null);
+    /**
+     * Persists a set of key => value pairs in the cache, with an optional TTL.
+     *
+     * @param iterable               $values A list of key => value pairs for a multiple-set operation.
+     * @param null|int|\DateInterval $ttl    Optional. The TTL value of this item. If no value is sent and
+     *                                       the driver supports TTL then the library may set a default value
+     *                                       for it or let the driver take care of that.
+     *
+     * @return bool True on success and false on failure.
+     *
+     * @throws \Psr\SimpleCache\InvalidArgumentException
+     *   MUST be thrown if $values is neither an array nor a Traversable,
+     *   or if any of the $values are not a legal value.
+     */
+    public function setMultiple($values, $ttl = null);
+    /**
+     * Deletes multiple cache items in a single operation.
+     *
+     * @param iterable $keys A list of string-based keys to be deleted.
+     *
+     * @return bool True if the items were successfully removed. False if there was an error.
+     *
+     * @throws \Psr\SimpleCache\InvalidArgumentException
+     *   MUST be thrown if $keys is neither an array nor a Traversable,
+     *   or if any of the $keys are not a legal value.
+     */
+    public function deleteMultiple($keys);
+    /**
+     * Determines whether an item is present in the cache.
+     *
+     * NOTE: It is recommended that has() is only to be used for cache warming type purposes
+     * and not to be used within your live applications operations for get/set, as this method
+     * is subject to a race condition where your has() will return true and immediately after,
+     * another script can remove it making the state of your app out of date.
+     *
+     * @param string $key The cache item key.
+     *
+     * @return bool
+     *
+     * @throws \Psr\SimpleCache\InvalidArgumentException
+     *   MUST be thrown if the $key string is not a legal value.
+     */
+    public function has($key);
+}