How do I enable "strict" mode? in

[samehdoush]

The responses to Structured Output are unbalanced. Sometimes they work, sometimes they don't.
I checked the request being sent and found that the following is being sent: "strict": false.
What is causing the unbalanced responses, and how can I fix the problem? Will setting strict to work?

<?php
namespace App\AI\Agents;

use NeuronAI\Providers\OpenAI\OpenAI;
use App\AI\Structure\QuizRes;
use NeuronAI\Agent;
use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\SystemPrompt;

class QuizGenerateAgent extends Agent
{
    public function __construct()
    {
    }

    public function provider(): AIProviderInterface
    {
        return new OpenAI(
            key: 'OPENAI_API_KEY',
            model: 'gpt-4.1',
        );
    }

    protected function getOutputClass(): string
    {
        return QuizRes::class;
    }

    public function instructions(): string
    {
        $lang = app()->getLocale();

        return new SystemPrompt(
            background: [
                "You are an expert quiz creator for educational platforms, specializing in creating comprehensive, professional quiz questions and answers.",
                "Always generate detailed and well-structured quiz content in the required language: $lang, even if the user writes in another language.",
                "Your questions must be clear, concise, and focused on testing knowledge in the specified topic area.",
                "Create various question types including single choice, multiple choice, text answers, and matching questions.",
                "The types of questions that must be included in the quiz are: single_choice, multiple_choice, text, matching.",
                "single_choice means selecting one correct answer from several options.",
                "multiple_choice means selecting several correct answers from several options.",
                "text means writing a correct textual answer.",
                "matching means matching the answers.",
            ],
            steps: [
                "Carefully analyze the topic and specific requirements from the user input.",
                "Generate 3-5 questions that cover different aspects of the topic.",
                "For each question, create appropriate answers with clear indicators for which answers are correct.",
                "Ensure each question has a type, content, hint, and topic field.",
                "For single_choice questions, provide one correct answer and 2-4 plausible incorrect answers.",
                "For multiple_choice questions, provide 2-3 correct answers and 2-3 plausible incorrect answers.",
                "For text questions, provide a simple array with one correct answer.",
                "For matching questions, create pairs with content and correct_text fields.",
                "Make sure the output is valid JSON with proper structure."
            ],
            output: [
                "You MUST generate valid, properly structured JSON",
                "IMPORTANT RULES:",
                "1. ONLY include the properties specified - nothing more.",
                "2. For matching questions, include the correct_text field in answers.",
                "3. For text questions, include a single answer in the answers array.",
                "4. Make sure all string values are properly escaped with double quotes.",
                "5. Do not add any extraneous text, comments, or explanation outside the JSON.",
                "6. Do not use special characters or escape sequences that could break the JSON structure.",
                "7. Make sure all array brackets and object braces are properly balanced and closed.",
                "8. The output should be a complete, valid JSON object ready for parsing.",
                "9. Each answer object MUST include: content, is_correct, correct_text (set correct_text to null unless the question type is matching).",
                "10. For single_choice and multiple_choice, correct_text must be null.",
                "11. For text questions, answers must be an empty array [].",
                "Output only a single JSON object, without any extra text, line breaks outside the JSON, or malformed fragments.",
            ]
        );
    }
}

<?php
namespace App\AI\Structure;
use NeuronAI\StructuredOutput\SchemaProperty;
use NeuronAI\StructuredOutput\Validation\Rules\ArrayOf;
use NeuronAI\StructuredOutput\Validation\Rules\IsNotNull;
class QuizRes
{

  /**
   * @var \App\AI\Structure\Questions[]
   */
  #[SchemaProperty(description: "quiz questions", required: true)]
  #[ArrayOf(Questions::class)]
  public array $questions;
}

<?php
namespace App\AI\Structure;
use NeuronAI\StructuredOutput\SchemaProperty;
use NeuronAI\StructuredOutput\Validation\Rules\ArrayOf;
use NeuronAI\StructuredOutput\Validation\Rules\Enum;
use NeuronAI\StructuredOutput\Validation\Rules\IsNull;
class Questions
{

    /**
     * @var \App\AI\Structure\multilang
     */

    #[SchemaProperty(description: "Question text", required: true)]
    public multilang $content;

    /**
     * @var \App\AI\Structure\multilang
     */

    #[SchemaProperty(description: "Hint to help the student solve the question", required: true)]
    public multilang $hint;


    /**
     * @var \App\AI\Structure\multilang
     */
    #[SchemaProperty(description: "General topic of the question", required: true)]
    public multilang $topic;


    #[SchemaProperty(description: "Question type, must be one of the following enum: single_choice, multiple_choice, text, matching", required: true)]
    #[Enum(values: ['single_choice', 'multiple_choice', 'text', 'matching'])]
    public string $type;


    /**
     * @var \App\AI\Structure\Answers[]
     */
    #[SchemaProperty(description: "Answers if the question type is not 'text'. If the type is 'text', return an empty array.", required: false)]
    #[ArrayOf(Answers::class)]
    #[IsNull]
    public array $answers = [];

}

<?php
namespace App\AI\Structure;

use NeuronAI\StructuredOutput\SchemaProperty;


class multilang
{
    #[SchemaProperty(description: "Content in Arabic as plain text, free from unclear symbols, code, or emojis", required: true)]
    public string $ar;

    #[SchemaProperty(description: "Content in English as plain text, free from unclear symbols, code, or emojis", required: true)]
    public string $en;

}

<?php
namespace App\AI\Structure;
use NeuronAI\StructuredOutput\SchemaProperty;
use NeuronAI\StructuredOutput\Validation\Rules\IsNull;

class Answers
{


  /**
   * @var \App\AI\Structure\multilang
   */
  #[SchemaProperty(description: "Answer text", required: false)]
  #[IsNull]
  public multilang $content;


  /**
   * @var \App\AI\Structure\multilang|null
   */
  #[SchemaProperty(description: "Second answer text, which should match the first answer if the question type is 'matching'. The user must find the match in the interface.", required: false)]
  #[IsNull]
  public ?multilang $correct_text = null;


  #[SchemaProperty(description: "If this answer is correct, it must be true", required: false)]
  #[IsNull]
  public bool $is_correct;


}

error :

NeuronAI Exception {"message":"Impossible to generate a structured response for the class App\\AI\\Structure\\QuizRes: 

- questions must be an array of App\\AI\\Structure\\Questions","type":"quiz"} 

[ilvalerione]

Hi @samehdoush, I released a patch to allow the usage of strict mode in OpenAI. You can pass the strict field creating the OpenAI provider instance:

new OpenAI(
    $_ENV['OPENAI_API_KEY'],
    'gpt-4o-mini',
    ['response_format' => ['json_schema' => ['strict' => true]]]
)