Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
0.00%
0 / 219
0.00%
0 / 10
 CRAP
0.00%
0 / 1
Jetpack_AI_Helper
0.00%
0 / 219
0.00%
0 / 10
 2862
0.00%
0 / 1
 get_status_permission_check
0.00%
0 / 7
0.00%
0 / 1
 6
 is_enabled
0.00%
0 / 6
0.00%
0 / 1
 20
 is_ai_chat_enabled
0.00%
0 / 6
0.00%
0 / 1
 12
 transient_name_for_image_generation
0.00%
0 / 1
0.00%
0 / 1
 2
 transient_name_for_completion
0.00%
0 / 1
0.00%
0 / 1
 2
 transient_name_for_ai_assistance_feature
0.00%
0 / 1
0.00%
0 / 1
 2
 mark_post_as_ai_assisted
0.00%
0 / 9
0.00%
0 / 1
 20
 get_gpt_completion
0.00%
0 / 67
0.00%
0 / 1
 210
 get_dalle_generation
0.00%
0 / 44
0.00%
0 / 1
 110
 get_ai_assistance_feature
0.00%
0 / 77
0.00%
0 / 1
 182
1<?php
2/**
3 * API helper for the AI blocks.
4 *
5 * @package automattic/jetpack
6 * @since 11.8
7 */
8
9use Automattic\Jetpack\Connection\Client;
10use Automattic\Jetpack\Connection\Manager;
11use Automattic\Jetpack\Search\Plan as Search_Plan;
12use Automattic\Jetpack\Status;
13use Automattic\Jetpack\Status\Visitor;
14
15/**
16 * Class Jetpack_AI_Helper
17 *
18 * @since 11.8
19 */
20class Jetpack_AI_Helper {
21    /**
22     * Allow new completion every X seconds. Will return cached result otherwise.
23     *
24     * @var int
25     */
26    public static $text_completion_cooldown_seconds = 15;
27
28    /**
29     * Cache images for a prompt for a month.
30     *
31     * @var int
32     */
33    public static $image_generation_cache_timeout = MONTH_IN_SECONDS;
34
35    /**
36     * Cache AI-assistant feature for 60 seconds.
37     *
38     * @var int
39     */
40    public static $ai_assistant_feature_cache_timeout = 60;
41
42    /**
43     * Cache AI-assistant errors for ten seconds.
44     *
45     * @var int
46     */
47    public static $ai_assistant_feature_error_cache_timeout = 10;
48
49    /**
50     * Stores the number of JetpackAI calls in case we want to mark AI-assisted posts some way.
51     *
52     * @var int
53     */
54    public static $post_meta_with_ai_generation_number = '_jetpack_ai_calls';
55
56    /**
57     * Storing the error to prevent repeated requests to WPCOM after failure.
58     *
59     * @var null|WP_Error
60     */
61    private static $ai_assistant_failed_request = null;
62
63    /**
64     * Checks if a given request is allowed to get AI data from WordPress.com.
65     *
66     * @param WP_REST_Request $request Full details about the request.
67     *
68     * @return true|WP_Error True if the request has access, WP_Error object otherwise.
69     */
70    public static function get_status_permission_check( $request ) { // phpcs:ignore Generic.CodeAnalysis.UnusedFunctionParameter, VariableAnalysis.CodeAnalysis.VariableAnalysis.UnusedVariable
71
72        /*
73         * This may need to be updated
74         * to take into account the different ways we can make requests
75         * (from a WordPress.com site, from a Jetpack site).
76         */
77        if ( ! current_user_can( 'edit_posts' ) ) {
78            return new WP_Error(
79                'rest_forbidden',
80                __( 'Sorry, you are not allowed to access Jetpack AI help on this site.', 'jetpack' ),
81                array( 'status' => rest_authorization_required_code() )
82            );
83        }
84
85        return true;
86    }
87
88    /**
89     * Return true if these features should be active on the current site.
90     * Currently, it's limited to WPCOM Simple and Atomic.
91     */
92    public static function is_enabled() {
93        $default = false;
94
95        if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
96            $default = true;
97        } elseif ( ( new Automattic\Jetpack\Status\Host() )->is_woa_site() ) {
98            $default = true;
99        }
100
101        /**
102         * Filter whether the AI features are enabled in the Jetpack plugin.
103         *
104         * @since 11.8
105         *
106         * @param bool $default Are AI features enabled? Defaults to false.
107         */
108        return apply_filters( 'jetpack_ai_enabled', $default );
109    }
110
111    /**
112     * Return true if the AI chat feature should be active on the current site.
113     *
114     * @todo IS_WPCOM (the endpoints need to be updated too).
115     *
116     * @return bool
117     */
118    public static function is_ai_chat_enabled() {
119        $default = false;
120
121        $connection = new Manager();
122        $plan       = new Search_Plan();
123        if ( $connection->is_connected() && $plan->supports_search() ) {
124            $default = true;
125        }
126
127        /**
128         * Filter whether the AI chat feature is enabled in the Jetpack plugin.
129         *
130         * @since 12.6
131         *
132         * @param bool $default Is AI chat enabled? Defaults to false.
133         */
134        return apply_filters( 'jetpack_ai_chat_enabled', $default );
135    }
136
137    /**
138     * Get the name of the transient for image generation. Unique per prompt and allows for reuse of results for the same prompt across entire WPCOM.
139     * I expext "puppy" to always be from cache.
140     *
141     * @param  string $prompt - Supplied prompt.
142     */
143    public static function transient_name_for_image_generation( $prompt ) {
144        return 'jetpack_openai_image_' . md5( $prompt );
145    }
146
147    /**
148     * Get the name of the transient for text completion. Unique per user, but not per text. Serves more as a cooldown.
149     */
150    public static function transient_name_for_completion() {
151        return 'jetpack_openai_completion_' . get_current_user_id(); // Cache for each user, so that other users dont get weird cached version from somebody else.
152    }
153
154    /**
155     * Get the name of the transient for AI assistance feature. Unique per user.
156     *
157     * @param  int $blog_id - Blog ID to get the transient name for.
158     * @return string
159     */
160    public static function transient_name_for_ai_assistance_feature( $blog_id ) {
161        return 'jetpack_openai_ai_assistance_feature_' . $blog_id;
162    }
163
164    /**
165     * Mark the edited post as "touched" by AI stuff.
166     *
167     * @param  int $post_id Post ID for which the content is being generated.
168     * @return void
169     */
170    private static function mark_post_as_ai_assisted( $post_id ) {
171        if ( ! $post_id ) {
172            return;
173        }
174        $previous = get_post_meta( $post_id, self::$post_meta_with_ai_generation_number, true );
175        if ( ! $previous ) {
176            $previous = 0;
177        } elseif ( ! is_numeric( $previous ) ) {
178            // Data corrupted, nothing to do.
179            return;
180        }
181        $new_value = intval( $previous ) + 1;
182        update_post_meta( $post_id, self::$post_meta_with_ai_generation_number, $new_value );
183    }
184
185    /**
186     * Get text back from WordPress.com based off a starting text.
187     *
188     * @param  string $content    The content provided to send to the AI.
189     * @param  int    $post_id    Post ID for which the content is being generated.
190     * @param  bool   $skip_cache Skip cache and force a new request.
191     * @return mixed
192     */
193    public static function get_gpt_completion( $content, $post_id, $skip_cache = false ) {
194        $content = wp_strip_all_tags( $content );
195        $cache   = get_transient( self::transient_name_for_completion() );
196        if ( $cache && ! $skip_cache ) {
197            return $cache;
198        }
199
200        if ( ( new Status() )->is_offline_mode() ) {
201            return new WP_Error(
202                'dev_mode',
203                __( 'Jetpack AI is not available in offline mode.', 'jetpack' )
204            );
205        }
206
207        $site_id = Manager::get_site_id();
208        if ( is_wp_error( $site_id ) ) {
209            return $site_id;
210        }
211
212        if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
213            if ( ! class_exists( 'OpenAI' ) ) {
214                \require_lib( 'openai' );
215            }
216
217            // Set the content for chatGPT endpoint
218            $data = array(
219                array(
220                    'role'    => 'user',
221                    'content' => $content,
222                ),
223            );
224
225            $openai            = new OpenAI( 'openai', array( 'post_id' => $post_id ) );
226            $moderation_result = $openai->moderate(
227                implode(
228                    ' ',
229                    array_map(
230                        function ( $msg ) {
231                            return $msg['role'] === 'user' ? $msg['content'] : '';
232                        },
233                        $data
234                    )
235                )
236            );
237
238            if ( is_wp_error( $moderation_result ) ) {
239                return $moderation_result;
240            }
241
242            $max_tokens = 480; // Default
243            $result     = $openai->request_chat_completion( $data, $max_tokens );
244
245            if ( is_wp_error( $result ) ) {
246                return $result;
247            }
248
249            $response = $result->choices[0]->message->content;
250
251            // In case of Jetpack we are setting a transient on the WPCOM and not the remote site. I think the 'get_current_user_id' may default for the connection owner at this point but we'll deal with this later.
252            set_transient( self::transient_name_for_completion(), $response, self::$text_completion_cooldown_seconds );
253            self::mark_post_as_ai_assisted( $post_id );
254            return $response;
255        }
256
257        $response = Client::wpcom_json_api_request_as_user(
258            sprintf( '/sites/%d/jetpack-ai/completions', $site_id ),
259            2,
260            array(
261                'method'  => 'post',
262                'headers' => array( 'content-type' => 'application/json' ),
263            ),
264            wp_json_encode(
265                array(
266                    'content' => $content,
267                ),
268                JSON_UNESCAPED_SLASHES
269            ),
270            'wpcom'
271        );
272
273        if ( is_wp_error( $response ) ) {
274            return $response;
275        }
276
277        $data = json_decode( wp_remote_retrieve_body( $response ) );
278
279        if ( wp_remote_retrieve_response_code( $response ) >= 400 ) {
280            return new WP_Error( $data->code, $data->message, $data->data );
281        }
282
283        // Do not cache if it should be skipped.
284        if ( ! $skip_cache ) {
285            set_transient( self::transient_name_for_completion(), $data, self::$text_completion_cooldown_seconds );
286        }
287        self::mark_post_as_ai_assisted( $post_id );
288
289        return $data;
290    }
291
292    /**
293     * Get an array of image objects back from WordPress.com based off a prompt.
294     *
295     * @param  string $prompt The prompt to generate images for.
296     * @param  int    $post_id Post ID for which the content is being generated.
297     * @return mixed
298     */
299    public static function get_dalle_generation( $prompt, $post_id ) {
300        $cache = get_transient( self::transient_name_for_image_generation( $prompt ) );
301        if ( $cache ) {
302            self::mark_post_as_ai_assisted( $post_id );
303            return $cache;
304        }
305
306        if ( ( new Status() )->is_offline_mode() ) {
307            return new WP_Error(
308                'dev_mode',
309                __( 'Jetpack AI is not available in offline mode.', 'jetpack' )
310            );
311        }
312
313        $site_id = Manager::get_site_id();
314        if ( is_wp_error( $site_id ) ) {
315            return $site_id;
316        }
317
318        if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
319            if ( ! class_exists( 'OpenAI' ) ) {
320                \require_lib( 'openai' );
321            }
322
323            $result = ( new OpenAI( 'openai', array( 'post_id' => $post_id ) ) )->request_dalle_generation( $prompt );
324            if ( is_wp_error( $result ) ) {
325                return $result;
326            }
327            set_transient( self::transient_name_for_image_generation( $prompt ), $result, self::$image_generation_cache_timeout );
328            self::mark_post_as_ai_assisted( $post_id );
329            return $result;
330        }
331
332        $response = Client::wpcom_json_api_request_as_user(
333            sprintf( '/sites/%d/jetpack-ai/images/generations', $site_id ),
334            2,
335            array(
336                'method'  => 'post',
337                'headers' => array( 'content-type' => 'application/json' ),
338            ),
339            wp_json_encode(
340                array(
341                    'prompt' => $prompt,
342                ),
343                JSON_UNESCAPED_SLASHES
344            ),
345            'wpcom'
346        );
347
348        if ( is_wp_error( $response ) ) {
349            return $response;
350        }
351
352        $data = json_decode( wp_remote_retrieve_body( $response ) );
353
354        if ( wp_remote_retrieve_response_code( $response ) >= 400 ) {
355            return new WP_Error( $data->code, $data->message, $data->data );
356        }
357        set_transient( self::transient_name_for_image_generation( $prompt ), $data, self::$image_generation_cache_timeout );
358        self::mark_post_as_ai_assisted( $post_id );
359
360        return $data;
361    }
362
363    /**
364     * Get an object with useful data about the requests made to the AI.
365     *
366     * @return mixed
367     */
368    public static function get_ai_assistance_feature() {
369        if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
370            // On WPCOM, we can get the ID from the site.
371            $blog_id                  = get_current_blog_id();
372            $has_ai_assistant_feature = \wpcom_site_has_feature( 'ai-assistant', $blog_id );
373
374            if ( ! class_exists( 'WPCOM\Jetpack_AI\Usage\Helper' ) ) {
375                if ( is_readable( WP_CONTENT_DIR . '/lib/jetpack-ai/usage/helper.php' ) ) {
376                    require_once WP_CONTENT_DIR . '/lib/jetpack-ai/usage/helper.php';
377                } else {
378                    return new WP_Error(
379                        'jetpack_ai_usage_helper_not_found',
380                        __( 'WPCOM\Jetpack_AI\Usage\Helper class not found.', 'jetpack' )
381                    );
382                }
383            }
384
385            if ( ! class_exists( 'WPCOM\Jetpack_AI\Feature_Control' ) ) {
386                if ( is_readable( WP_CONTENT_DIR . '/lib/jetpack-ai/feature-control.php' ) ) {
387                    require_once WP_CONTENT_DIR . '/lib/jetpack-ai/feature-control.php';
388                } else {
389                    return new WP_Error(
390                        'jetpack_ai_feature_control_not_found',
391                        __( 'WPCOM\Jetpack_AI\Feature_Control class not found.', 'jetpack' )
392                    );
393                }
394            }
395
396            $chrome_ai_tokens = array();
397            if ( ! class_exists( 'WPCOM\Jetpack_AI\Chrome_AI_Tokens' ) ) {
398                if ( is_readable( WP_CONTENT_DIR . '/lib/jetpack-ai/chrome-ai-tokens.php' ) ) {
399                    require_once WP_CONTENT_DIR . '/lib/jetpack-ai/chrome-ai-tokens.php';
400                    $chrome_ai_tokens = WPCOM\Jetpack_AI\Chrome_AI_Tokens::get_tokens();
401                }
402            }
403
404            // Determine the upgrade type
405            $upgrade_type = wpcom_is_vip( $blog_id ) ? 'vip' : 'default';
406
407            return array(
408                'has-feature'          => $has_ai_assistant_feature,
409                'is-over-limit'        => WPCOM\Jetpack_AI\Usage\Helper::is_over_limit( $blog_id ),
410                'requests-count'       => WPCOM\Jetpack_AI\Usage\Helper::get_all_time_requests_count( $blog_id ),
411                'requests-limit'       => WPCOM\Jetpack_AI\Usage\Helper::get_free_requests_limit( $blog_id ),
412                'usage-period'         => WPCOM\Jetpack_AI\Usage\Helper::get_period_data( $blog_id ),
413                'site-require-upgrade' => WPCOM\Jetpack_AI\Usage\Helper::site_requires_upgrade( $blog_id ),
414                'upgrade-type'         => $upgrade_type,
415                'upgrade-url'          => WPCOM\Jetpack_AI\Usage\Helper::get_upgrade_url( $blog_id ),
416                'current-tier'         => WPCOM\Jetpack_AI\Usage\Helper::get_current_tier( $blog_id ),
417                'next-tier'            => WPCOM\Jetpack_AI\Usage\Helper::get_next_tier( $blog_id ),
418                'tier-plans'           => WPCOM\Jetpack_AI\Usage\Helper::get_tier_plans_list(),
419                'tier-plans-enabled'   => WPCOM\Jetpack_AI\Usage\Helper::ai_tier_plans_enabled(),
420                'costs'                => WPCOM\Jetpack_AI\Usage\Helper::get_costs(),
421                'features-control'     => WPCOM\Jetpack_AI\Feature_Control::get_features(),
422                'chrome-ai-tokens'     => $chrome_ai_tokens,
423            );
424        }
425
426        // Outside of WPCOM, we need to fetch the data from the site.
427        $blog_id = Jetpack_Options::get_option( 'id' );
428
429        // Try to pick the AI Assistant feature from cache.
430        $transient_name = self::transient_name_for_ai_assistance_feature( $blog_id );
431        $cache          = get_transient( $transient_name );
432        if ( $cache ) {
433            return $cache;
434        }
435
436        if ( null !== static::$ai_assistant_failed_request ) {
437            return static::$ai_assistant_failed_request;
438        }
439
440        $request_path = sprintf( '/sites/%d/jetpack-ai/ai-assistant-feature', $blog_id );
441
442        $wpcom_request = Client::wpcom_json_api_request_as_user(
443            $request_path,
444            'v2',
445            array(
446                'method'  => 'GET',
447                'headers' => array(
448                    'X-Forwarded-For' => ( new Visitor() )->get_ip( true ),
449                ),
450                'timeout' => 30,
451            ),
452            null,
453            'wpcom'
454        );
455
456        $response_code = wp_remote_retrieve_response_code( $wpcom_request );
457        if ( 200 === $response_code ) {
458            $ai_assistant_feature_data = json_decode( wp_remote_retrieve_body( $wpcom_request ), true );
459
460            // Cache the AI Assistant feature, for Jetpack sites.
461            set_transient( $transient_name, $ai_assistant_feature_data, self::$ai_assistant_feature_cache_timeout );
462
463            return $ai_assistant_feature_data;
464        } else {
465            $error = new WP_Error(
466                'failed_to_fetch_data',
467                esc_html__( 'Unable to fetch the requested data.', 'jetpack' ),
468                array(
469                    'status' => $response_code,
470                    'ts'     => time(),
471                )
472            );
473
474            // Cache the AI Assistant feature error, for Jetpack sites, avoid API hammering.
475            set_transient( $transient_name, $error, self::$ai_assistant_feature_error_cache_timeout );
476
477            static::$ai_assistant_failed_request = $error;
478
479            return $error;
480        }
481    }
482}