console/controllers/CheckController.php - dev - v.bolshakov/AIEcosystem-Testing

console/controllers/CheckController.php
228 строк6 KB
Developer
Initial commit
03 авг 2026, 17:43
03 авг 2026, 17:437433917
<?php

namespace console\controllers;

use common\components\AnthropicComponent;
use common\components\DeepseekComponent;
use common\components\GoogleAlComponent;
use common\components\OpenAIComponent;
use common\components\OpenRouteComponent;
use common\helpers\AiHelper;
use common\helpers\DateHelper;
use common\models\Provider;
use common\models\stat\ProviderCheck;
use DeepSeek\DeepSeekClient;
use fholbrook\Openrouter\DTO\Chat;
use fholbrook\Openrouter\DTO\ChatRequest;
use fholbrook\Openrouter\OpenRouter;
use Gemini\Data\Content;
use OpenAI\Client;
use Yii;
use yii\console\{Controller, ExitCode};


/**
 * Work with Open AI components
 *
 * @author Dmitry E. Semenov <sde.tomsk@gmail.com>
 * @copyright Self (c) 2023
 */
class CheckController extends BaseController
{

    /**
     * Delete OLD Data
     * @return int
     */
    public function actionClear()
    {
        $date = DateHelper::now(time() - DateHelper::MONTH);

        ProviderCheck::deleteAll(['<', 'created_at', $date]);

        return ExitCode::OK;
    }

    /**
     * Update Metric statistics
     */
    public function actionMetric()
    {
        AiHelper::updateMetric();
    }

    /**
     * Check GPT
     */
    public function actionGpt()
    {
        try {
            $openAI = new OpenAIComponent();
            /** @var Client $client */
            $client = $openAI->getClient();

            $response = $client->completions()->create([
                'model'       => 'gpt-4o-mini',
                'prompt'      => 'p',
                'max_tokens'  => 1,
                'temperature' => 0
            ]);
            AiHelper::logCheck([
                'provider_id' => Provider::GPT,
                'timeout'     => microtime(true) - $this->start_at,
            ]);
        } catch (\Exception $exception) {
            AiHelper::logCheck([
                'provider_id' => Provider::GPT,
                'timeout'     => microtime(true) - $this->start_at,
                'status'      => $exception->getStatusCode(),
                'error'       => $exception->getMessage(),
            ]);
        }

        return ExitCode::OK;
    }

    /**
     * Check OpenRouter
     */
    public function actionOpenRouter()
    {
        try {
            $openAI = new OpenRouteComponent();
            /** @var OpenRouter $client */
            $client = $openAI->getClient();

            $messages[] = [
                'role'    => 'user',
                'content' => 'p'
            ];

            $chatData = new ChatRequest(
                chat: new Chat(
                    messages: $messages,
                ),
                model: '',
            );

            $response = $client->chat->chat($chatData);

            AiHelper::logCheck([
                'provider_id' => Provider::OPEN_ROUTER,
                'timeout'     => microtime(true) - $this->start_at,
            ]);
        } catch (\Exception $exception) {
            AiHelper::logCheck([
                'provider_id' => Provider::OPEN_ROUTER,
                'timeout'     => microtime(true) - $this->start_at,
                'status'      => $exception->getStatusCode(),
                'error'       => $exception->getMessage(),
            ]);
        }

        return ExitCode::OK;
    }

    /**
     * Check Anthropic
     */
    public function actionAnthropic()
    {
        try {
            $openAI = new AnthropicComponent();
            $client = $openAI->getClient();
            $messages = [];
            $messages[] = [
                'role'    => 'user',
                'content' => 'p'
            ];
            $result = $client->messages()->create([
                'model'      => 'claude-3-haiku-20240307',
                'max_tokens' => 1,
                'messages'   => $messages,
            ]);
            AiHelper::logCheck([
                'provider_id' => Provider::ANTHROPIC,
                'timeout'     => microtime(true) - $this->start_at,
            ]);
        } catch (\Exception $exception) {
            AiHelper::logCheck([
                'provider_id' => Provider::ANTHROPIC,
                'timeout'     => microtime(true) - $this->start_at,
                'status'      => $exception->getStatusCode(),
                'error'       => $exception->getMessage(),
            ]);
        }

        return ExitCode::OK;
    }

    /**
     * Check Deepseek
     */
    public function actionDeepseek()
    {
        try {
            $openAI = new DeepseekComponent();
            /** @var DeepSeekClient $client */
            $client = $openAI->getClient();

            $response = $client
                ->withModel('deepseek-chat')
                ->withStream()
                ->setMaxTokens(1)
                ->setResponseFormat('text')
                ->query('p')
                ->run();

            AiHelper::logCheck([
                'provider_id' => Provider::DEEPSEEK,
                'timeout'     => microtime(true) - $this->start_at,
            ]);

        } catch (\Exception $exception) {
            AiHelper::logCheck([
                'provider_id' => Provider::DEEPSEEK,
                'timeout'     => microtime(true) - $this->start_at,
                'status'      => $exception->getStatusCode(),
                'error'       => $exception->getMessage(),
            ]);
        }

        return ExitCode::OK;
    }

    /**
     * Check Google AI
     */
    public function actionGoogleAi()
    {
        try {
            $openAI = new GoogleAlComponent();
            /** @var \Gemini\Client $client */
            $client = $openAI->getClient();

            $contents = Content::parse('p');

            $result = $client
                ->generativeModel(model: 'models/gemini-2.5-flash-lite')
                ->generateContent($contents);

            AiHelper::logCheck([
                'provider_id' => Provider::GOOGLE_AI,
                'timeout'     => microtime(true) - $this->start_at,
            ]);

        } catch (\Exception $exception) {
            AiHelper::logCheck([
                'provider_id' => Provider::GOOGLE_AI,
                'timeout'     => microtime(true) - $this->start_at,
                'status'      => $exception->getErrorCode(),
                'error'       => $exception->getMessage(),
            ]);
        }

        return ExitCode::OK;
    }

}