Add Auto function execution about client HOT 5 OPEN

<?php declare(strict_types=1);

namespace Example;

use Attribute;

#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PARAMETER)]
final class Description {

    public function __construct(
        public string $value,
    ) {}

}

<?php declare(strict_types=1);

namespace Example;

use Illuminate\Support\Facades\Log;
use Illuminate\Support\Str;
use ReflectionClass;
use ReflectionEnum;
use ReflectionException;
use ReflectionParameter;
use RuntimeException;

trait HasFunctions {

    private array $registered_functions = [];

    /**
     * @throws ReflectionException
     */
    public function register(array $function_classes): void {
        foreach ($function_classes as $class_name) {
            if ( !class_exists($class_name)) {
                continue;
            }

            $function_class = new ReflectionClass($class_name);
            $function_name = Str::snake(basename(str_replace('\\', '/', $class_name)));

            if (! $function_class->hasMethod('handle')) {
                Log::warning(sprintf('Function class %s has no "handle" method', $function_class));

                continue;
            }

            $tool_definition = [
                'type'     => 'function',
                'function' => [ 'name' => $function_name ],
            ];

            // set function description, if it has one
            if ( !empty($descriptions = $function_class->getAttributes(Description::class))) {
                $tool_definition['function']['description'] = implode(
                    separator: "\n",
                    array: array_map(static fn($td) => $td->newInstance()->value, $descriptions),
                );
            }

            if ($function_class->getMethod('handle')->getNumberOfParameters() > 0) {
                $tool_definition['function']['parameters'] = $this->parseFunctionParameters($function_class);
            }

            $this->registered_functions[ $class_name ] = $tool_definition;
        }
    }

    /**
     * @throws ReflectionException
     */
    public function call(string $function_name, array $arguments = []): mixed {
        if (null === $function_class = array_key_first(array_filter($this->registered_functions, static fn($registered_function) => $registered_function['function']['name'] === $function_name))) {
            return null;
        }

        $function_class = new ReflectionClass($function_class);
        $handle_method = $function_class->getMethod('handle');

        $params = [];
        foreach ($handle_method->getParameters() as $parameter) {
            if ( !array_key_exists($parameter->name, $arguments) && !$parameter->isOptional() && !$parameter->isDefaultValueAvailable()) {
                throw new RuntimeException(sprintf('Parameter %s is required', $parameter->name));
            }

            // check if parameter type is an Enum and add fetch a valid value
            if (($parameter_type = $parameter->getType()) !== null && !$parameter_type->isBuiltin()) {
                if (enum_exists($parameter_type->getName())) {
                    $params[$parameter->name] = $parameter_type->getName()::tryFrom($arguments[$parameter->name]) ?? $parameter->getDefaultValue();

                    continue;
                }
            }

            $params[$parameter->name] = $arguments[$parameter->name] ?? $parameter->getDefaultValue();
        }

        return $handle_method->invoke(new $function_class->name, ...$params);
    }

    /**
     * @throws ReflectionException
     */
    private function parseFunctionParameters(ReflectionClass $tool): array {
        $parameters = [ 'type' => 'object' ];

        if (count($method_parameters = $tool->getMethod('handle')->getParameters()) > 0) {
            $parameters['properties'] = [];
        }

        foreach ($method_parameters as $method_parameter) {
            $property = [ 'type' => $this->getFunctionParameterType($method_parameter) ];

            // set property description, if it has one
            if (!empty($descriptions = $method_parameter->getAttributes(Description::class))) {
                $property['description'] = implode(
                    separator: "\n",
                    array: array_map(static fn($pd) => $pd->newInstance()->value, $descriptions),
                );
            }

            // register parameter to the required properties list if it's not optional
            if ( !$method_parameter->isOptional()) {
                $parameters['required'] ??= [];
                $parameters['required'][] = $method_parameter->getName();
            }

            // check if parameter type is an Enum and add it's valid values to the property
            if (($parameter_type = $method_parameter->getType()) !== null && !$parameter_type->isBuiltin()) {
                if (enum_exists($parameter_type->getName())) {
                    $property['type'] = 'string';
                    $property['enum'] = array_column((new ReflectionEnum($parameter_type->getName()))->getConstants(), 'value');
                }
            }

            $parameters['properties'][$method_parameter->getName()] = $property;
        }

        return $parameters;
    }

    private function getFunctionParameterType(ReflectionParameter $parameter): string {
        if (null === $parameter_type = $parameter->getType()) {
            return 'string';
        }

        if ( !$parameter_type->isBuiltin()) {
            return $parameter_type->getName();
        }

        return match ($parameter_type->getName()) {
            'bool'  => 'boolean',
            'int'   => 'integer',
            'float' => 'number',

            default => 'string',
        };
    }

}

<?php declare(strict_types=1);

namespace Example\Functions;

use Example\Description;

#[Description('Having all the necessary information, create the lead for the Sales department')]
final class MakeLead {

    public function handle(
        #[Description('Customer\'s name')]
        string $name,

        #[Description('Customer\'s surname')]
        string $surname,

        #[Description('Customers\' email')]
        string $email,

        #[Description('Customer\'s phone number')]
        string $phone,

        #[Description('Chosen product by the customer for purchase')]
        int $product_id,
    ): ?array {
    
        // TODO: do your function logic gere
        
        return null;
    }

}

<?php declare(strict_types=1);

namespace Example;

use Example\HasFunctions;
use Example\Functions\MakeLead;
use Example\Functions\SearchProducts;
use Example\Functions\AnotherUsefulFunction;

class App {
    use HasFunctions;

    public function __construct() {
        $this->register([
            MakeLead::class,
            SearchProducts::class,
            AnotherUsefulFunction::class,
            // ...
        ]);
    }
    
    public function run() {
        $response = $client->chat()->create([
            'model' => 'gpt-3.5-turbo-0613',
            'messages' => [
                // ... message history
                [ 'role' => 'user', 'content' => 'Yes, I want to purchase one coffee machine' ],
            ],
            'tools' => array_values($this->registered_functions),
        ]);
        
        $choice = $response->choices[0];
        if ($choice->finishReason === 'tool_calls') {        
            foreach ($choice->message->toolCalls as $tool_call) {
                // execute the function call
                $result = $this->call($tool_call->function->name, json_decode($tool_call->function->arguments));

                // TODO: do something with the result ...
            }
        }
    }

}