ref

Author: Guikingone

docs/components/platform.rst

@@ -510,7 +510,7 @@ This platform can also be configured when using the bundle::
                     platforms:
                         - 'ai.platform.ollama'
                         - 'ai.platform.openai'
-                    rate_limiter: ''
+                    rate_limiter: 'limiter.failover_platform' # To define in config/packages/rate_limiter.yaml
 
 .. note::
 

src/ai-bundle/composer.json

@@ -28,6 +28,7 @@
         "symfony/console": "^7.3|^8.0",
         "symfony/dependency-injection": "^7.3|^8.0",
         "symfony/framework-bundle": "^7.3|^8.0",
+        "symfony/rate-limiter": "^7.3|^8.0",
         "symfony/string": "^7.3|^8.0"
     },
     "require-dev": {

src/ai-bundle/config/options.php

@@ -122,9 +122,7 @@
                                 ->arrayNode('platforms')
                                     ->scalarPrototype()->end()
                                 ->end()
-                                ->integerNode('retry_period')
-                                    ->defaultValue(60)
-                                ->end()
+                                ->stringNode('rate_limiter')->cannotBeEmpty()->end()
                             ->end()
                         ->end()
                     ->end()

src/ai-bundle/src/AiBundle.php

@@ -522,8 +522,8 @@ private function processPlatformConfig(string $type, array $platform, ContainerB
                             static fn (string $wrappedPlatform): Reference => new Reference($wrappedPlatform),
                             $config['platforms'],
                         ),
+                        new Reference($config['rate_limiter']),
                         new Reference(ClockInterface::class),
-                        $config['retry_period'],
                         new Reference(LoggerInterface::class),
                     ])
                     ->addTag('proxy', ['interface' => PlatformInterface::class])

src/ai-bundle/tests/DependencyInjection/AiBundleTest.php

@@ -87,6 +87,8 @@
 use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\HttpClient\HttpClient;
+use Symfony\Component\RateLimiter\RateLimiterFactory;
+use Symfony\Component\RateLimiter\Storage\InMemoryStorage;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 
 class AiBundleTest extends TestCase
@@ -4039,6 +4041,7 @@ public function testFailoverPlatformCanBeCreated()
                                 'ai.platform.ollama',
                                 'ai.platform.openai',
                             ],
+                            'rate_limiter' => 'limiter.failover_platform',
                         ],
                     ],
                 ],
@@ -4059,56 +4062,9 @@ public function testFailoverPlatformCanBeCreated()
             new Reference('ai.platform.openai'),
         ], $definition->getArgument(0));
         $this->assertInstanceOf(Reference::class, $definition->getArgument(1));
-        $this->assertSame(ClockInterface::class, (string) $definition->getArgument(1));
-        $this->assertSame(60, $definition->getArgument(2));
-        $this->assertInstanceOf(Reference::class, $definition->getArgument(3));
-        $this->assertSame(LoggerInterface::class, (string) $definition->getArgument(3));
-
-        $this->assertTrue($definition->hasTag('proxy'));
-        $this->assertSame([['interface' => PlatformInterface::class]], $definition->getTag('proxy'));
-        $this->assertTrue($definition->hasTag('ai.platform'));
-        $this->assertSame([['name' => 'failover']], $definition->getTag('ai.platform'));
-
-        $this->assertTrue($container->hasAlias('Symfony\AI\Platform\PlatformInterface $main'));
-
-        $container = $this->buildContainer([
-            'ai' => [
-                'platform' => [
-                    'ollama' => [
-                        'host_url' => 'http://127.0.0.1:11434',
-                    ],
-                    'openai' => [
-                        'api_key' => 'sk-openai_key_full',
-                    ],
-                    'failover' => [
-                        'main' => [
-                            'platforms' => [
-                                'ai.platform.ollama',
-                                'ai.platform.openai',
-                            ],
-                            'retry_period' => 120,
-                        ],
-                    ],
-                ],
-            ],
-        ]);
-
-        $this->assertTrue($container->hasDefinition('ai.platform.failover.main'));
-
-        $definition = $container->getDefinition('ai.platform.failover.main');
-
-        $this->assertTrue($definition->isLazy());
-        $this->assertSame(FailoverPlatform::class, $definition->getClass());
-
-        $this->assertCount(4, $definition->getArguments());
-        $this->assertCount(2, $definition->getArgument(0));
-        $this->assertEquals([
-            new Reference('ai.platform.ollama'),
-            new Reference('ai.platform.openai'),
-        ], $definition->getArgument(0));
-        $this->assertInstanceOf(Reference::class, $definition->getArgument(1));
-        $this->assertSame(ClockInterface::class, (string) $definition->getArgument(1));
-        $this->assertSame(120, $definition->getArgument(2));
+        $this->assertSame('limiter.failover_platform', (string) $definition->getArgument(1));
+        $this->assertInstanceOf(Reference::class, $definition->getArgument(2));
+        $this->assertSame(ClockInterface::class, (string) $definition->getArgument(2));
         $this->assertInstanceOf(Reference::class, $definition->getArgument(3));
         $this->assertSame(LoggerInterface::class, (string) $definition->getArgument(3));
 
@@ -7115,6 +7071,15 @@ private function buildContainer(array $configuration): ContainerBuilder
         $container->setParameter('kernel.build_dir', 'public');
         $container->setDefinition(ClockInterface::class, new Definition(MonotonicClock::class));
         $container->setDefinition(LoggerInterface::class, new Definition(NullLogger::class));
+        $container->setDefinition('limiter.failover_platform', new Definition(RateLimiterFactory::class, [
+            [
+                'policy' => 'sliding_window',
+                'id' => 'test',
+                'interval' => '60 seconds',
+                'limit' => 1,
+            ],
+            new Definition(InMemoryStorage::class),
+        ]));
 
         $extension = (new AiBundle())->getContainerExtension();
         $extension->load($configuration, $container);
@@ -7176,13 +7141,7 @@ private function getFullConfig(): array
                                 'ai.platform.ollama',
                                 'ai.platform.openai',
                             ],
-                        ],
-                        'main_with_custom_retry_period' => [
-                            'platforms' => [
-                                'ai.platform.ollama',
-                                'ai.platform.openai',
-                            ],
-                            'retry_period' => 120,
+                            'rate_limiter' => 'limiter.failover_platform',
                         ],
                     ],
                     'gemini' => [

src/platform/src/FailoverPlatform.php

@@ -17,19 +17,27 @@
 use Symfony\AI\Platform\Exception\RuntimeException;
 use Symfony\AI\Platform\ModelCatalog\ModelCatalogInterface;
 use Symfony\AI\Platform\Result\DeferredResult;
+use Symfony\Component\Clock\ClockInterface;
+use Symfony\Component\Clock\MonotonicClock;
 use Symfony\Component\RateLimiter\RateLimiterFactoryInterface;
 
 /**
  * @author Guillaume Loulier <[email protected]>
  */
 final class FailoverPlatform implements PlatformInterface
 {
+    /**
+     * @var \SplObjectStorage<PlatformInterface, int>
+     */
+    private readonly \SplObjectStorage $failedPlatforms;
+
     /**
      * @param PlatformInterface[] $platforms
      */
     public function __construct(
         private readonly iterable $platforms,
         private readonly RateLimiterFactoryInterface $rateLimiterFactory,
+        private readonly ClockInterface $clock = new MonotonicClock(),
         private readonly LoggerInterface $logger = new NullLogger(),
     ) {
         if ([] === $platforms) {
@@ -39,6 +47,8 @@ public function __construct(
         if (!interface_exists(RateLimiterFactoryInterface::class)) {
             throw new RuntimeException('For using the FailoverPlatform, a symfony/rate-limiter implementation is required. Try running "composer require symfony/rate-limiter".');
         }
+
+        $this->failedPlatforms = new \SplObjectStorage();
     }
 
     public function invoke(string $model, object|array|string $input, array $options = []): DeferredResult
@@ -56,14 +66,14 @@ private function do(\Closure $func): DeferredResult|ModelCatalogInterface
         foreach ($this->platforms as $platform) {
             $limiter = $this->rateLimiterFactory->create($platform::class);
 
-            if (!$limiter->consume()->isAccepted()) {
-                continue;
-            }
-
             try {
+                if ($limiter->consume()->isAccepted() && $this->failedPlatforms->offsetExists($platform)) {
+                    $this->failedPlatforms->offsetUnset($platform);
+                }
+
                 return $func($platform);
             } catch (\Throwable $throwable) {
-                $limiter->consume();
+                $this->failedPlatforms->offsetSet($platform, $this->clock->now()->getTimestamp());
 
                 $this->logger->error('The {platform} platform due to an error/exception: {message}', [
                     'platform' => $platform::class,