Handlers should implement interface

[ilhooq]

For some reasons, it would be great if all api Handlers implement an interface.

One reason could be to use a common function/method to handle errors, for instance:

function handleError(OpenaiHandlerInterface $handler) {
   log('Response', $handler->toArray());
   // ...
}

As base interface I suggest to use PSR-15 Psr\Http\Server\RequestHandlerInterface.

The final interface could be:

interface OpenaiHandlerInterface extends \Psr\Http\Server\RequestHandlerInterface
{
    public function toModel(): object;
   
    public function toArray(): object;

   // ...
}

[thejamescollins]

Hi there @ilhooq,

Thank you for your idea to implement interfaces in Handlers, it sounds like an interesting idea.

I would like to learn more about what you think an improvement like this would achieve.

Can you please describe your use-case in a bit more detail?

If this was implemented, how would this improve your application and your use of this library?

Thank you,

James

[ilhooq]

Hi James,

First of all, I just want to say that, in the actual state, the library works fine. Thank you for your effort.

What I explained above is just a suggestion for an enhancement.

The goal of the use case I described (a common error handler) is to avoid to check errors for each handler separately. In the actual state, it's possible to achieve this goal but without to be sure that the handler implement the method toArray, unless using code introspection.

Now, with the use of a common interface, it would guaranty that each handler implements the toArray and toModel methods. It would make the use of the library a little bit more comfortable.

Another use case could be to create a custom handler factory. If each handler implements a create method described in the interface, it would be possible to achieve something like this:

function createHandler(string $name): OpenaiHandlerInterface
{
  //...
}

$handler = createHandler('edits');
// Now, we are sure that $handler have the create method
$handler->create($request);

I Hope this will be helpful.

Regards

[thejamescollins]

First of all, I just want to say that, in the actual state, the library works fine. Thank you for your effort.

Thank you for the kind words, I appreciate it!

I'll be discussing these ideas with our team as we plan out future improvements and changes.

Thanks again,

James

[the-csaba]

Hi @ilhooq ,

Can you tell me more about the use case of interfaces from a library consumer perspective?

I am especially interested in the handleError method. How would that help your development?

If you have any other ideas, please tell us too.

I appreciate your time and effort.

[ilhooq]

Hi @om4csaba,

In a consumer perspective, here is an example on how we could use interface:

use Tectalic\OpenAi\Manager;
use Tectalic\OpenAi\Authentication;
use Tectalic\OpenAi\Client;
use Tectalic\OpenAi\ClientException;
use Tectalic\OpenAi\HandlerInterface; 

function handleError(HandlerInterface $handler)
{
    var_dump($handler->getRequest());
    var_dump($handler->getResponse());
    var_dump($handler->toArray());
   // ...
}

function openaiRequest(Client $client, string $handler, array $request)
{
    $handler = $client->$handler();
   
    if (!$handler instanceof HandlerInterface) {
        throw new RuntimeException('Handler must be instance of Tectalic\OpenAi\HandlerInterface');
    }
    
    try {
        $response = $handler->create($request);
        // ...
    } catch (ClientException $e) {
        handleError($handler);
    }
}

$client = Manager::build(new \GuzzleHttp\Client(), new Authentication(getenv('OPENAI_API_KEY')));

openaiRequest(
    $client,
    'completions',
    [
         'model' => 'text-davinci-002',
         'prompt' => 'Lorem ipsum',
    ]
);

openaiRequest(
    $client,
    'edits',
    [
         'model' => 'text-davinci-edit-001',
         'input' => 'Lorem ipsum',
    ]
);

[the-csaba]

Hi @ilhooq

Thank you for the detailed explanation.

It certainly makes sense now.

Even though our roadmap is not public, I am adding this as a feature request.