Implement ModelCatalog system with YAML configuration support

- Replaced individual model constants with centralized ModelCatalog system
- Added ModelCatalogInterface with getModel(), getModels(), and getModelConfig() methods
- Created AbstractModelCatalog base class for common functionality
- Implemented platform-specific ModelCatalog services (e.g., ai.model_catalog.openai)
- Updated Platform::invoke() to accept string model names instead of Model objects
- Added YAML configuration support for custom models with capability validation
- Removed constructors from Gpt, Embeddings, Whisper, and DallE classes
- Consolidated all OpenAI models (GPT, Embeddings, Whisper, DALL-E) into ModelCatalog
- Updated OpenAI examples to use string model names
- Added test coverage for model name normalization and ModelCatalog functionality
- Configured AiBundle to create model catalog services from YAML configuration

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: OskarStark

examples/openai/additional-model.php

@@ -44,6 +44,6 @@
     ),
 );
 
-$result = $platform->invoke($modelCatalog->getModel('gpt-4o-mini-transcribe'), $messages);
+$result = $platform->invoke('gpt-4o-mini-transcribe', $messages);
 
 echo $result->getResult()->getContent().\PHP_EOL;

examples/openai/audio-transcript.php

@@ -16,9 +16,8 @@
 require_once dirname(__DIR__).'/bootstrap.php';
 
 $platform = PlatformFactory::create(env('OPENAI_API_KEY'), http_client());
-$model = new Whisper(Whisper::WHISPER_1);
 $file = Audio::fromFile(dirname(__DIR__, 2).'/fixtures/audio.mp3');
 
-$result = $platform->invoke($model, $file);
+$result = $platform->invoke('whisper-1', $file);
 
 echo $result->asText().\PHP_EOL;

examples/openai/chat.php

@@ -17,13 +17,12 @@
 require_once dirname(__DIR__).'/bootstrap.php';
 
 $platform = PlatformFactory::create(env('OPENAI_API_KEY'), http_client());
-$model = new Gpt(Gpt::GPT_4O_MINI);
 
 $messages = new MessageBag(
     Message::forSystem('You are a pirate and you write funny.'),
     Message::ofUser('What is the Symfony framework?'),
 );
-$result = $platform->invoke($model, $messages, [
+$result = $platform->invoke('gpt-4o-mini', $messages, [
     'max_tokens' => 500, // specific options just for this call
 ]);
 

examples/openai/embeddings.php

@@ -15,9 +15,8 @@
 require_once dirname(__DIR__).'/bootstrap.php';
 
 $platform = PlatformFactory::create(env('OPENAI_API_KEY'), http_client());
-$embeddings = new Embeddings(Embeddings::TEXT_3_SMALL);
 
-$result = $platform->invoke($embeddings, <<<TEXT
+$result = $platform->invoke('text-embedding-3-small', <<<TEXT
     Once upon a time, there was a country called Japan. It was a beautiful country with a lot of mountains and rivers.
     The people of Japan were very kind and hardworking. They loved their country very much and took care of it. The
     country was very peaceful and prosperous. The people lived happily ever after.

examples/openai/image-output-dall-e-2.php

@@ -17,7 +17,7 @@
 $platform = PlatformFactory::create(env('OPENAI_API_KEY'), http_client());
 
 $result = $platform->invoke(
-    model: new DallE(DallE::DALL_E_2),
+    model: 'dall-e-2',
     input: 'A cartoon-style elephant with a long trunk and large ears.',
     options: [
         'response_format' => 'url', // Generate response as URL

examples/openai/image-output-dall-e-3.php

@@ -18,7 +18,7 @@
 $platform = PlatformFactory::create(env('OPENAI_API_KEY'), http_client());
 
 $result = $platform->invoke(
-    model: new DallE(name: DallE::DALL_E_3),
+    model: 'dall-e-3',
     input: 'A cartoon-style elephant with a long trunk and large ears.',
     options: [
         'response_format' => 'url', // Generate response as URL

src/ai-bundle/config/options.php

@@ -189,6 +189,10 @@
                                 ->enumPrototype(Capability::class)
                                 ->end()
                                 ->defaultValue([])
+                                ->validate()
+                                    ->ifEmpty()
+                                    ->thenInvalid('At least one capability must be specified for each model.')
+                                ->end()
                             ->end()
                         ->end()
                     ->end()

src/ai-bundle/src/AiBundle.php

@@ -1170,21 +1170,16 @@ private function processModelCatalogConfig(string $platformName, array $models,
         foreach ($models as $modelName => $modelConfig) {
             $capabilities = $modelConfig['capabilities'] ?? [];
 
-            // If no capabilities provided, add all capabilities from Capability enum
-            if (empty($capabilities)) {
-                $capabilityEnums = Capability::cases();
-            } else {
-                // Convert string capabilities to Capability enums
-                if (is_string($capabilities)) {
-                    $capabilities = explode(',', $capabilities);
-                }
-                
-                $capabilityEnums = [];
-                foreach ($capabilities as $capability) {
-                    $capability = trim($capability);
-                    if ($capability !== '') {
-                        $capabilityEnums[] = Capability::from($capability);
-                    }
+            // Convert string capabilities to Capability enums
+            if (is_string($capabilities)) {
+                $capabilities = explode(',', $capabilities);
+            }
+            
+            $capabilityEnums = [];
+            foreach ($capabilities as $capability) {
+                $capability = trim($capability);
+                if ($capability !== '') {
+                    $capabilityEnums[] = Capability::from($capability);
                 }
             }
 
@@ -1195,9 +1190,7 @@ private function processModelCatalogConfig(string $platformName, array $models,
         }
 
         // Create platform-specific model catalog service
-        $catalogServiceId = 'ai.model_catalog.' . $platformName;
-        $catalogDefinition = new Definition(ModelCatalog::class, [$modelDefinitions]);
-        $container->setDefinition($catalogServiceId, $catalogDefinition);
+        $container->setDefinition('ai.model_catalog.' . $platformName, new Definition(ModelCatalog::class, [$modelDefinitions]));
     }
 
 }

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

@@ -1946,6 +1946,50 @@ public function testIndexerWithSourceFiltersAndTransformers()
         $this->assertSame('logger', (string) $arguments[6]);
     }
 
+    public function testModelNamesAreNotNormalized()
+    {
+        $container = $this->buildContainer([
+            'ai' => [
+                'model' => [
+                    'openai' => [
+                        'foo-bar' => [
+                            'class' => Gpt::class,
+                            'capabilities' => ['INPUT_TEXT', 'OUTPUT_TEXT'],
+                        ],
+                        'my_custom-model.v2' => [
+                            'class' => Embeddings::class,
+                            'capabilities' => ['INPUT_TEXT'],
+                        ],
+                        'gpt-4o-mini-transcribe' => [
+                            'class' => Gpt::class,
+                            'capabilities' => ['INPUT_AUDIO', 'INPUT_TEXT', 'OUTPUT_TEXT'],
+                        ],
+                    ],
+                ],
+            ],
+        ]);
+
+        // Verify that model catalog service is created for the platform
+        $this->assertTrue($container->hasDefinition('ai.model_catalog.openai'));
+
+        // Get the model catalog definition and check that model names are preserved exactly
+        $catalogDefinition = $container->getDefinition('ai.model_catalog.openai');
+        $arguments = $catalogDefinition->getArguments();
+        
+        $this->assertCount(1, $arguments);
+        $modelDefinitions = $arguments[0];
+
+        // Verify that model names are not normalized and maintain their original format
+        $this->assertArrayHasKey('foo-bar', $modelDefinitions);
+        $this->assertArrayHasKey('my_custom-model.v2', $modelDefinitions);
+        $this->assertArrayHasKey('gpt-4o-mini-transcribe', $modelDefinitions);
+
+        // Verify model configurations are correct
+        $this->assertSame(Gpt::class, $modelDefinitions['foo-bar']['class']);
+        $this->assertSame(Embeddings::class, $modelDefinitions['my_custom-model.v2']['class']);
+        $this->assertSame(Gpt::class, $modelDefinitions['gpt-4o-mini-transcribe']['class']);
+    }
+
     private function buildContainer(array $configuration): ContainerBuilder
     {
         $container = new ContainerBuilder();

src/platform/src/AbstractModelCatalog.php

@@ -20,24 +20,24 @@
 abstract class AbstractModelCatalog implements ModelCatalogInterface
 {
     /**
-     * @var array<string, array{class: string, platform: string, capabilities: list<Capability>}>
+     * @var array<string, array{class: string, capabilities: list<Capability>}>
      */
     protected readonly array $models;
 
     public function getModel(string $modelName): Model
     {
-        $modelConfig = $this->getModelConfig($modelName);
-
-        if (null === $modelConfig) {
+        if (!isset($this->models[$modelName])) {
             throw ModelNotFoundException::forModelName($modelName);
         }
 
+        $modelConfig = $this->models[$modelName];
         $modelClass = $modelConfig['class'];
+        
         if (!class_exists($modelClass)) {
             throw new InvalidArgumentException(\sprintf('Model class "%s" does not exist.', $modelClass));
         }
 
-        $model = new $modelClass();
+        $model = new $modelClass($modelName, $modelConfig['capabilities']);
         if (!$model instanceof Model) {
             throw new InvalidArgumentException(\sprintf('Model class "%s" must extend %s.', $modelClass, Model::class));
         }
@@ -46,18 +46,23 @@ public function getModel(string $modelName): Model
     }
 
     /**
-     * @return list<string>
+     * @return array<string, array{class: string, capabilities: list<Capability>}>
      */
     public function getModels(): array
     {
-        return array_keys($this->models);
+        return $this->models;
     }
 
     /**
-     * @return array{class: string, platform: string, capabilities: list<Capability>}|null
+     * @return array{class: string, capabilities: list<Capability>}
      */
-    private function getModelConfig(string $name): ?array
+    public function getModelConfig(string $modelName): array
     {
-        return $this->models[$name] ?? null;
+        if (!isset($this->models[$modelName])) {
+            throw ModelNotFoundException::forModelName($modelName);
+        }
+
+        return $this->models[$modelName];
     }
+
 }