refactor: replace Webmozart assertions with native PHP exceptions for input validation

Spomky · Spomky · commit c774eb29a03a · 2025-07-15T09:16:52.000+02:00
diff --git a/src/platform/composer.json b/src/platform/composer.json
@@ -32,15 +32,13 @@
         "symfony/property-info": "^6.4 || ^7.1",
         "symfony/serializer": "^6.4 || ^7.1",
         "symfony/type-info": "^7.2.3",
-        "symfony/uid": "^6.4 || ^7.1",
-        "webmozart/assert": "^1.11"
+        "symfony/uid": "^6.4 || ^7.1"
     },
     "require-dev": {
         "async-aws/bedrock-runtime": "^0.1.0",
         "codewithkyrian/transformers": "^0.5.3",
         "phpstan/phpstan": "^2.1.17",
         "phpstan/phpstan-symfony": "^2.0.6",
-        "phpstan/phpstan-webmozart-assert": "^2.0.0",
         "phpunit/phpunit": "^11.5",
         "symfony/console": "^6.4 || ^7.1",
         "symfony/dotenv": "^6.4 || ^7.1",
diff --git a/src/platform/src/Bridge/Azure/OpenAI/EmbeddingsModelClient.php b/src/platform/src/Bridge/Azure/OpenAI/EmbeddingsModelClient.php
@@ -17,7 +17,6 @@
 use Symfony\Component\HttpClient\EventSourceHttpClient;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface;
-use Webmozart\Assert\Assert;
 
 /**
  * @author Christopher Hertel <mail@christopher-hertel.de>
@@ -34,11 +33,10 @@ public function __construct(
         #[\SensitiveParameter] private string $apiKey,
     ) {
         $this->httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
-        Assert::notStartsWith($baseUrl, 'http://', 'The base URL must not contain the protocol.');
-        Assert::notStartsWith($baseUrl, 'https://', 'The base URL must not contain the protocol.');
-        Assert::stringNotEmpty($deployment, 'The deployment must not be empty.');
-        Assert::stringNotEmpty($apiVersion, 'The API version must not be empty.');
-        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
+        str_starts_with($this->baseUrl, 'https://') || str_starts_with($this->baseUrl, 'http://') || throw new \InvalidArgumentException('The base URL must start with "https://" or "http://".');
+        '' !== $deployment || throw new \InvalidArgumentException('The deployment must not be empty.');
+        '' !== $apiVersion || throw new \InvalidArgumentException('The API version must not be empty.');
+        '' !== $apiKey || throw new \InvalidArgumentException('The API key must not be empty.');
     }
 
     public function supports(Model $model): bool
diff --git a/src/platform/src/Bridge/Azure/OpenAI/GPTModelClient.php b/src/platform/src/Bridge/Azure/OpenAI/GPTModelClient.php
@@ -17,7 +17,6 @@
 use Symfony\Component\HttpClient\EventSourceHttpClient;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface;
-use Webmozart\Assert\Assert;
 
 /**
  * @author Christopher Hertel <mail@christopher-hertel.de>
@@ -34,11 +33,10 @@ public function __construct(
         #[\SensitiveParameter] private string $apiKey,
     ) {
         $this->httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
-        Assert::notStartsWith($baseUrl, 'http://', 'The base URL must not contain the protocol.');
-        Assert::notStartsWith($baseUrl, 'https://', 'The base URL must not contain the protocol.');
-        Assert::stringNotEmpty($deployment, 'The deployment must not be empty.');
-        Assert::stringNotEmpty($apiVersion, 'The API version must not be empty.');
-        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
+        str_starts_with($this->baseUrl, 'https://') || str_starts_with($this->baseUrl, 'http://') || throw new \InvalidArgumentException('The base URL must start with "https://" or "http://".');
+        '' !== $deployment || throw new \InvalidArgumentException('The deployment must not be empty.');
+        '' !== $apiVersion || throw new \InvalidArgumentException('The API version must not be empty.');
+        '' !== $apiKey || throw new \InvalidArgumentException('The API key must not be empty.');
     }
 
     public function supports(Model $model): bool
diff --git a/src/platform/src/Bridge/Azure/OpenAI/WhisperModelClient.php b/src/platform/src/Bridge/Azure/OpenAI/WhisperModelClient.php
@@ -18,7 +18,6 @@
 use Symfony\Component\HttpClient\EventSourceHttpClient;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface;
-use Webmozart\Assert\Assert;
 
 /**
  * @author Christopher Hertel <mail@christopher-hertel.de>
@@ -35,11 +34,10 @@ public function __construct(
         #[\SensitiveParameter] private string $apiKey,
     ) {
         $this->httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
-        Assert::notStartsWith($baseUrl, 'http://', 'The base URL must not contain the protocol.');
-        Assert::notStartsWith($baseUrl, 'https://', 'The base URL must not contain the protocol.');
-        Assert::stringNotEmpty($deployment, 'The deployment must not be empty.');
-        Assert::stringNotEmpty($apiVersion, 'The API version must not be empty.');
-        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
+        str_starts_with($this->baseUrl, 'https://') || str_starts_with($this->baseUrl, 'http://') || throw new \InvalidArgumentException('The base URL must start with "https://" or "http://".');
+        '' !== $deployment || throw new \InvalidArgumentException('The deployment must not be empty.');
+        '' !== $apiVersion || throw new \InvalidArgumentException('The API version must not be empty.');
+        '' !== $apiKey || throw new \InvalidArgumentException('The API key must not be empty.');
     }
 
     public function supports(Model $model): bool
diff --git a/src/platform/src/Bridge/OpenAI/DallE/Base64Image.php b/src/platform/src/Bridge/OpenAI/DallE/Base64Image.php
@@ -11,8 +11,6 @@
 
 namespace Symfony\AI\Platform\Bridge\OpenAI\DallE;
 
-use Webmozart\Assert\Assert;
-
 /**
  * @author Denis Zunke <denis.zunke@gmail.com>
  */
@@ -21,6 +19,6 @@
     public function __construct(
         public string $encodedImage,
     ) {
-        Assert::stringNotEmpty($encodedImage, 'The base64 encoded image generated must be given.');
+        '' !== $encodedImage || throw new \InvalidArgumentException('The base64 encoded image must not be empty.');
     }
 }
diff --git a/src/platform/src/Bridge/OpenAI/DallE/ModelClient.php b/src/platform/src/Bridge/OpenAI/DallE/ModelClient.php
@@ -19,7 +19,6 @@
 use Symfony\AI\Platform\ResponseConverterInterface as PlatformResponseConverter;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface as HttpResponse;
-use Webmozart\Assert\Assert;
 
 /**
  * @see https://platform.openai.com/docs/api-reference/images/create
@@ -33,8 +32,8 @@ public function __construct(
         #[\SensitiveParameter]
         private string $apiKey,
     ) {
-        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
-        Assert::startsWith($apiKey, 'sk-', 'The API key must start with "sk-".');
+        '' !== $apiKey || throw new \InvalidArgumentException('The API key must not be empty.');
+        str_starts_with($apiKey, 'sk-') || throw new \InvalidArgumentException('The API key must start with "sk-".');
     }
 
     public function supports(Model $model): bool
diff --git a/src/platform/src/Bridge/OpenAI/DallE/UrlImage.php b/src/platform/src/Bridge/OpenAI/DallE/UrlImage.php
@@ -11,8 +11,6 @@
 
 namespace Symfony\AI\Platform\Bridge\OpenAI\DallE;
 
-use Webmozart\Assert\Assert;
-
 /**
  * @author Denis Zunke <denis.zunke@gmail.com>
  */
@@ -21,6 +19,6 @@
     public function __construct(
         public string $url,
     ) {
-        Assert::stringNotEmpty($url, 'The image url must be given.');
+        '' !== $url || throw new \InvalidArgumentException('The image url must not be empty.');
     }
 }
diff --git a/src/platform/src/Bridge/OpenAI/Embeddings/ModelClient.php b/src/platform/src/Bridge/OpenAI/Embeddings/ModelClient.php
@@ -16,7 +16,6 @@
 use Symfony\AI\Platform\ModelClientInterface as PlatformResponseFactory;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface;
-use Webmozart\Assert\Assert;
 
 /**
  * @author Christopher Hertel <mail@christopher-hertel.de>
@@ -28,8 +27,8 @@ public function __construct(
         #[\SensitiveParameter]
         private string $apiKey,
     ) {
-        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
-        Assert::startsWith($apiKey, 'sk-', 'The API key must start with "sk-".');
+        '' !== $apiKey || throw new \InvalidArgumentException('The API key must not be empty.');
+        str_starts_with($apiKey, 'sk-') || throw new \InvalidArgumentException('The API key must start with "sk-".');
     }
 
     public function supports(Model $model): bool
diff --git a/src/platform/src/Bridge/OpenAI/GPT/ModelClient.php b/src/platform/src/Bridge/OpenAI/GPT/ModelClient.php
@@ -17,7 +17,6 @@
 use Symfony\Component\HttpClient\EventSourceHttpClient;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface;
-use Webmozart\Assert\Assert;
 
 /**
  * @author Christopher Hertel <mail@christopher-hertel.de>
@@ -32,8 +31,8 @@ public function __construct(
         private string $apiKey,
     ) {
         $this->httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
-        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
-        Assert::startsWith($apiKey, 'sk-', 'The API key must start with "sk-".');
+        '' !== $apiKey || throw new \InvalidArgumentException('The API key must not be empty.');
+        str_starts_with($apiKey, 'sk-') || throw new \InvalidArgumentException('The API key must start with "sk-".');
     }
 
     public function supports(Model $model): bool
diff --git a/src/platform/src/Bridge/OpenAI/Whisper/ModelClient.php b/src/platform/src/Bridge/OpenAI/Whisper/ModelClient.php
@@ -16,7 +16,6 @@
 use Symfony\AI\Platform\ModelClientInterface as BaseModelClient;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface;
-use Webmozart\Assert\Assert;
 
 /**
  * @author Christopher Hertel <mail@christopher-hertel.de>
@@ -28,7 +27,7 @@ public function __construct(
         #[\SensitiveParameter]
         private string $apiKey,
     ) {
-        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
+        '' !== $apiKey || throw new \InvalidArgumentException('The API key must not be empty.');
     }
 
     public function supports(Model $model): bool
diff --git a/src/platform/src/Bridge/OpenRouter/Client.php b/src/platform/src/Bridge/OpenRouter/Client.php
@@ -20,7 +20,6 @@
 use Symfony\Component\HttpClient\EventSourceHttpClient;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface;
-use Webmozart\Assert\Assert;
 
 /**
  * @author rglozman
@@ -34,8 +33,8 @@ public function __construct(
         #[\SensitiveParameter] private string $apiKey,
     ) {
         $this->httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
-        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
-        Assert::startsWith($apiKey, 'sk-', 'The API key must start with "sk-".');
+        '' !== $apiKey || throw new \InvalidArgumentException('The API key must not be empty.');
+        str_starts_with($apiKey, 'sk-') || throw new \InvalidArgumentException('The API key must start with "sk-".');
     }
 
     public function supports(Model $model): bool
diff --git a/src/platform/src/Bridge/Replicate/LlamaModelClient.php b/src/platform/src/Bridge/Replicate/LlamaModelClient.php
@@ -15,7 +15,6 @@
 use Symfony\AI\Platform\Model;
 use Symfony\AI\Platform\ModelClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface;
-use Webmozart\Assert\Assert;
 
 /**
  * @author Christopher Hertel <mail@christopher-hertel.de>
@@ -34,7 +33,7 @@ public function supports(Model $model): bool
 
     public function request(Model $model, array|string $payload, array $options = []): ResponseInterface
     {
-        Assert::isInstanceOf($model, Llama::class);
+        $model instanceof Llama || throw new \InvalidArgumentException(\sprintf('The model must be an instance of "%s".', Llama::class));
 
         return $this->client->request(\sprintf('meta/meta-%s', $model->getName()), 'predictions', $payload);
     }
diff --git a/src/platform/src/Contract/JsonSchema/Attribute/With.php b/src/platform/src/Contract/JsonSchema/Attribute/With.php
@@ -11,8 +11,6 @@
 
 namespace Symfony\AI\Platform\Contract\JsonSchema\Attribute;
 
-use Webmozart\Assert\Assert;
-
 /**
  * @author Oskar Stark <oskarstark@googlemail.com>
  */
@@ -54,95 +52,95 @@ public function __construct(
         public ?bool $dependentRequired = null,
     ) {
         if (\is_array($enum)) {
-            Assert::allString($enum);
+            array_filter($enum, fn ($item) => \is_string($item)) === $enum || throw new \InvalidArgumentException('All enum values must be strings.');
         }
 
         if (\is_string($const)) {
-            Assert::stringNotEmpty(trim($const));
+            '' !== trim($const) || throw new \InvalidArgumentException('Const string must not be empty.');
         }
 
         if (\is_string($pattern)) {
-            Assert::stringNotEmpty(trim($pattern));
+            '' !== trim($pattern) || throw new \InvalidArgumentException('Pattern string must not be empty.');
         }
 
         if (\is_int($minLength)) {
-            Assert::greaterThanEq($minLength, 0);
+            $minLength >= 0 || throw new \InvalidArgumentException('MinLength must be greater than or equal to 0.');
 
             if (\is_int($maxLength)) {
-                Assert::greaterThanEq($maxLength, $minLength);
+                $maxLength >= $minLength || throw new \InvalidArgumentException('MaxLength must be greater than or equal to minLength.');
             }
         }
 
         if (\is_int($maxLength)) {
-            Assert::greaterThanEq($maxLength, 0);
+            $maxLength >= 0 || throw new \InvalidArgumentException('MaxLength must be greater than or equal to 0.');
         }
 
         if (\is_int($minimum)) {
-            Assert::greaterThanEq($minimum, 0);
+            $minimum >= 0 || throw new \InvalidArgumentException('Minimum must be greater than or equal to 0.');
 
             if (\is_int($maximum)) {
-                Assert::greaterThanEq($maximum, $minimum);
+                $maximum >= $minimum || throw new \InvalidArgumentException('Maximum must be greater than or equal to minimum.');
             }
         }
 
         if (\is_int($maximum)) {
-            Assert::greaterThanEq($maximum, 0);
+            $maximum >= 0 || throw new \InvalidArgumentException('Maximum must be greater than or equal to 0.');
         }
 
         if (\is_int($multipleOf)) {
-            Assert::greaterThanEq($multipleOf, 0);
+            $multipleOf >= 0 || throw new \InvalidArgumentException('MultipleOf must be greater than or equal to 0.');
         }
 
         if (\is_int($exclusiveMinimum)) {
-            Assert::greaterThanEq($exclusiveMinimum, 0);
+            $exclusiveMinimum >= 0 || throw new \InvalidArgumentException('ExclusiveMinimum must be greater than or equal to 0.');
 
             if (\is_int($exclusiveMaximum)) {
-                Assert::greaterThanEq($exclusiveMaximum, $exclusiveMinimum);
+                $exclusiveMaximum >= $exclusiveMinimum || throw new \InvalidArgumentException('ExclusiveMaximum must be greater than or equal to exclusiveMinimum.');
             }
         }
 
         if (\is_int($exclusiveMaximum)) {
-            Assert::greaterThanEq($exclusiveMaximum, 0);
+            $exclusiveMaximum >= 0 || throw new \InvalidArgumentException('ExclusiveMaximum must be greater than or equal to 0.');
         }
 
         if (\is_int($minItems)) {
-            Assert::greaterThanEq($minItems, 0);
+            $minItems >= 0 || throw new \InvalidArgumentException('MinItems must be greater than or equal to 0.');
 
             if (\is_int($maxItems)) {
-                Assert::greaterThanEq($maxItems, $minItems);
+                $maxItems >= $minItems || throw new \InvalidArgumentException('MaxItems must be greater than or equal to minItems.');
             }
         }
 
         if (\is_int($maxItems)) {
-            Assert::greaterThanEq($maxItems, 0);
+            $maxItems >= 0 || throw new \InvalidArgumentException('MaxItems must be greater than or equal to 0.');
         }
 
         if (\is_bool($uniqueItems)) {
-            Assert::true($uniqueItems);
+            true === $uniqueItems || throw new \InvalidArgumentException('UniqueItems must be true when specified.');
         }
 
         if (\is_int($minContains)) {
-            Assert::greaterThanEq($minContains, 0);
+            $minContains >= 0 || throw new \InvalidArgumentException('MinContains must be greater than or equal to 0.');
 
             if (\is_int($maxContains)) {
-                Assert::greaterThanEq($maxContains, $minContains);
+                $maxContains >= $minContains || throw new \InvalidArgumentException('MaxContains must be greater than or equal to minContains.');
             }
         }
 
         if (\is_int($maxContains)) {
-            Assert::greaterThanEq($maxContains, 0);
+            $maxContains >= 0 || throw new \InvalidArgumentException('MaxContains must be greater than or equal to 0.');
         }
 
         if (\is_int($minProperties)) {
-            Assert::greaterThanEq($minProperties, 0);
+            $minProperties >= 0 || throw new \InvalidArgumentException('MinProperties must be greater than or equal to 0.');
 
             if (\is_int($maxProperties)) {
-                Assert::greaterThanEq($maxProperties, $minProperties);
+                $maxProperties >= $minProperties || throw new \InvalidArgumentException('MaxProperties must be greater than or equal to minProperties.');
             }
         }
 
         if (\is_int($maxProperties)) {
-            Assert::greaterThanEq($maxProperties, 0);
+            $maxProperties >= 0 || throw new \InvalidArgumentException('MaxProperties must be greater than or equal to 0.');
         }
     }
 }
diff --git a/src/platform/tests/Contract/JsonSchema/Attribute/ToolParameterTest.php b/src/platform/tests/Contract/JsonSchema/Attribute/ToolParameterTest.php
diff --git a/src/store/composer.json b/src/store/composer.json
diff --git a/src/store/src/Document/TextDocument.php b/src/store/src/Document/TextDocument.php

Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,6 @@`
`11`	`11`
`12`	`12`	`namespace Symfony\AI\Platform\Bridge\OpenAI\DallE;`
`13`	`13`
`14`		`-use Webmozart\Assert\Assert;`
`15`		`-`
`16`	`14`	`/**`
`17`	`15`	`* @author Denis Zunke <denis.zunke@gmail.com>`
`18`	`16`	`*/`
`@@ -21,6 +19,6 @@`
`21`	`19`	`public function __construct(`
`22`	`20`	`public string $encodedImage,`
`23`	`21`	`) {`
`24`		`- Assert::stringNotEmpty($encodedImage, 'The base64 encoded image generated must be given.');`
	`22`	`+ '' !== $encodedImage \|\| throw new \InvalidArgumentException('The base64 encoded image must not be empty.');`
`25`	`23`	`}`
`26`	`24`	`}`