| @@ -68,8 +68,19 @@ | ||
| 68 | 68 | */ |
| 69 | 69 | private const AI_CONTENT_MAX_LENGTH = 5000; |
| 70 | 70 | |
| 71 | 71 | /** |
| 72 | + * Ceilings for the OpenAI-compatible endpoint's model listing (#721). | |
| 73 | + * | |
| 74 | + * The endpoint is a host the site owner named, not one we trust: a | |
| 75 | + * misconfigured or hostile server can answer `GET /models` with an | |
| 76 | + * unbounded body or a catalogue of thousands. Both are bounded here — the | |
| 77 | + * field this feeds is a suggestion list, and the UI shows the first few. | |
| 78 | + */ | |
| 79 | + private const MAX_MODELS_RESPONSE_BYTES = 262144; // 256 KB. | |
| 80 | + private const MAX_ENDPOINT_MODELS = 200; | |
| 81 | + | |
| 82 | + /** | |
| 72 | 83 | * Sanitize and hard-cap an AI `content` request parameter. |
| 73 | 84 | * |
| 74 | 85 | * Used as the `sanitize_callback` for every AI endpoint's `content` arg so |
| 75 | 86 | * the server enforces its own maximum regardless of what a direct REST |
| @@ -193,8 +204,41 @@ | ||
| 193 | 204 | 'openrouter_model' => [ |
| 194 | 205 | 'type' => 'string', |
| 195 | 206 | 'sanitize_callback' => 'sanitize_text_field', |
| 196 | 207 | ], |
| 208 | + // OpenAI-compatible endpoint (#721). The URL is not run through | |
| 209 | + // esc_url_raw here: Settings::sanitize_setting() validates it | |
| 210 | + // (scheme, SSRF guard) and save_settings() reports the reason | |
| 211 | + // when it refuses, which a sanitize callback cannot do. | |
| 212 | + 'openai_compatible_base_url' => [ | |
| 213 | + 'type' => 'string', | |
| 214 | + 'sanitize_callback' => 'sanitize_text_field', | |
| 215 | + ], | |
| 216 | + 'openai_compatible_api_key' => [ | |
| 217 | + 'type' => 'string', | |
| 218 | + 'sanitize_callback' => 'sanitize_text_field', | |
| 219 | + ], | |
| 220 | + 'openai_compatible_model' => [ | |
| 221 | + 'type' => 'string', | |
| 222 | + 'sanitize_callback' => 'sanitize_text_field', | |
| 223 | + ], | |
| 224 | + 'openai_compatible_timeout' => [ | |
| 225 | + 'type' => 'integer', | |
| 226 | + 'minimum' => 10, | |
| 227 | + 'maximum' => 600, | |
| 228 | + 'sanitize_callback' => 'absint', | |
| 229 | + 'validate_callback' => 'rest_validate_request_arg', | |
| 230 | + ], | |
| 231 | + 'openai_compatible_supports_images' => [ | |
| 232 | + 'type' => 'boolean', | |
| 233 | + ], | |
| 234 | + 'openai_compatible_json_mode' => [ | |
| 235 | + 'type' => 'boolean', | |
| 236 | + ], | |
| 237 | + 'openai_compatible_price_per_million' => [ | |
| 238 | + 'type' => 'number', | |
| 239 | + 'minimum' => 0, | |
| 240 | + ], | |
| 197 | 241 | 'max_tokens' => [ |
| 198 | 242 | 'type' => 'integer', |
| 199 | 243 | 'minimum' => 1, |
| 200 | 244 | 'maximum' => 32000, |
| @@ -228,8 +272,28 @@ | ||
| 228 | 272 | 'enable_import_export' => [ |
| 229 | 273 | 'type' => 'boolean', |
| 230 | 274 | 'sanitize_callback' => 'rest_sanitize_boolean', |
| 231 | 275 | ], |
| 276 | + // AI spend controls (#448). `max_requests_per_minute` is not | |
| 277 | + // new, but it was never reachable: registered since 1.0 and | |
| 278 | + // rendered nowhere, so no user could see the throttle that was | |
| 279 | + // limiting them. | |
| 280 | + 'max_requests_per_minute' => [ | |
| 281 | + 'type' => 'integer', | |
| 282 | + 'minimum' => 0, | |
| 283 | + 'sanitize_callback' => 'absint', | |
| 284 | + 'validate_callback' => 'rest_validate_request_arg', | |
| 285 | + ], | |
| 286 | + 'ai_daily_request_limit' => [ | |
| 287 | + 'type' => 'integer', | |
| 288 | + 'minimum' => 0, | |
| 289 | + 'sanitize_callback' => 'absint', | |
| 290 | + 'validate_callback' => 'rest_validate_request_arg', | |
| 291 | + ], | |
| 292 | + 'ai_paused' => [ | |
| 293 | + 'type' => 'boolean', | |
| 294 | + 'sanitize_callback' => 'rest_sanitize_boolean', | |
| 295 | + ], | |
| 232 | 296 | ], |
| 233 | 297 | ]); |
| 234 | 298 | |
| 235 | 299 | |
| @@ -487,11 +551,45 @@ | ||
| 487 | 551 | 'type' => 'string', |
| 488 | 552 | 'required' => false, |
| 489 | 553 | 'sanitize_callback' => 'sanitize_text_field', |
| 490 | 554 | ], |
| 555 | + // Only used by the openai_compatible provider: the URL on | |
| 556 | + // screen, so an unsaved endpoint can be tested before saving. | |
| 557 | + 'base_url' => [ | |
| 558 | + 'type' => 'string', | |
| 559 | + 'required' => false, | |
| 560 | + 'sanitize_callback' => 'sanitize_text_field', | |
| 561 | + ], | |
| 562 | + // Only used by the openai_compatible provider: the JSON mode | |
| 563 | + // toggle on screen. Omitted, the saved setting decides. | |
| 564 | + 'json_mode' => [ | |
| 565 | + 'type' => 'boolean', | |
| 566 | + 'required' => false, | |
| 567 | + ], | |
| 491 | 568 | ], |
| 492 | 569 | ]); |
| 493 | 570 | |
| 571 | + // Ask an OpenAI-compatible endpoint what models it serves. Ollama, LM | |
| 572 | + // Studio and vLLM all answer GET {base}/models; a gateway that does not | |
| 573 | + // simply leaves the user typing the id by hand (#721). | |
| 574 | + register_rest_route(self::NAMESPACE, '/ai/models', [ | |
| 575 | + 'methods' => 'POST', | |
| 576 | + 'callback' => [$this, 'list_endpoint_models'], | |
| 577 | + 'permission_callback' => [$this, 'check_admin_permissions'], | |
| 578 | + 'args' => [ | |
| 579 | + 'base_url' => [ | |
| 580 | + 'type' => 'string', | |
| 581 | + 'required' => false, | |
| 582 | + 'sanitize_callback' => 'sanitize_text_field', | |
| 583 | + ], | |
| 584 | + 'api_key' => [ | |
| 585 | + 'type' => 'string', | |
| 586 | + 'required' => false, | |
| 587 | + 'sanitize_callback' => 'sanitize_text_field', | |
| 588 | + ], | |
| 589 | + ], | |
| 590 | + ]); | |
| 591 | + | |
| 494 | 592 | register_rest_route(self::NAMESPACE, '/ai/providers', [ |
| 495 | 593 | 'methods' => 'GET', |
| 496 | 594 | 'callback' => [$this, 'get_ai_providers'], |
| 497 | 595 | 'permission_callback' => [$this, 'check_basic_permissions'], |
| @@ -661,8 +759,17 @@ | ||
| 661 | 759 | $enabled = (bool) $settings->get('enable_rate_limiting', true); |
| 662 | 760 | if (!$enabled) { |
| 663 | 761 | return true; |
| 664 | 762 | } |
| 763 | + // A non-positive limit means unlimited, matching AI\Manager and the | |
| 764 | + // label on the control (#448). This used to fall through to | |
| 765 | + // max(1, $limit) below, which turned a 0 into the most restrictive | |
| 766 | + // setting available rather than the least: the first request of each | |
| 767 | + // minute was allowed and every other one got a 429. Harmless while the | |
| 768 | + // field was rendered nowhere, user-facing the moment it was surfaced. | |
| 769 | + if ($limit <= 0) { | |
| 770 | + return true; | |
| 771 | + } | |
| 665 | 772 | $now = time(); |
| 666 | 773 | $window = 60; |
| 667 | 774 | $key = 'thinkrank_rl_' . md5($bucket_id); |
| 668 | 775 | $bucket = get_transient($key); |
| @@ -671,9 +778,9 @@ | ||
| 671 | 778 | } |
| 672 | 779 | if ($now - ($bucket['start'] ?? 0) >= $window) { |
| 673 | 780 | $bucket = ['start' => $now, 'count' => 0]; |
| 674 | 781 | } |
| 675 | - if (($bucket['count'] ?? 0) >= max(1, $limit)) { | |
| 782 | + if (($bucket['count'] ?? 0) >= $limit) { | |
| 676 | 783 | return new \WP_Error('rate_limited', __('Rate limit exceeded. Please wait a moment and try again.', 'thinkrank'), ['status' => 429]); |
| 677 | 784 | } |
| 678 | 785 | $bucket['count']++; |
| 679 | 786 | set_transient($key, $bucket, $window); |
| @@ -815,8 +922,15 @@ | ||
| 815 | 922 | 'gemini_api_key' => $settings_instance->get('gemini_api_key', ''), |
| 816 | 923 | 'gemini_model' => $settings_instance->get('gemini_model', \ThinkRank\Core\Settings::DEFAULT_GEMINI_MODEL), |
| 817 | 924 | 'openrouter_api_key' => $settings_instance->get('openrouter_api_key', ''), |
| 818 | 925 | 'openrouter_model' => $settings_instance->get('openrouter_model', \ThinkRank\Core\Settings::DEFAULT_OPENROUTER_MODEL), |
| 926 | + 'openai_compatible_base_url' => $settings_instance->get('openai_compatible_base_url', ''), | |
| 927 | + 'openai_compatible_api_key' => $settings_instance->get('openai_compatible_api_key', ''), | |
| 928 | + 'openai_compatible_model' => $settings_instance->get('openai_compatible_model', ''), | |
| 929 | + 'openai_compatible_timeout' => (int) $settings_instance->get('openai_compatible_timeout', \ThinkRank\Core\Settings::DEFAULT_OPENAI_COMPATIBLE_TIMEOUT), | |
| 930 | + 'openai_compatible_supports_images' => (bool) $settings_instance->get('openai_compatible_supports_images', false), | |
| 931 | + 'openai_compatible_json_mode' => (bool) $settings_instance->get('openai_compatible_json_mode', false), | |
| 932 | + 'openai_compatible_price_per_million' => (float) $settings_instance->get('openai_compatible_price_per_million', 0), | |
| 819 | 933 | 'max_tokens' => $settings_instance->get('max_tokens', 1000), |
| 820 | 934 | 'temperature' => $settings_instance->get('temperature', 0.7), |
| 821 | 935 | 'cache_duration' => $settings_instance->get('cache_duration', 3600), |
| 822 | 936 | 'keep_data_on_uninstall' => (bool) $settings_instance->get('keep_data_on_uninstall', true), |
| @@ -823,8 +937,11 @@ | ||
| 823 | 937 | 'enable_migration_tools' => (bool) $settings_instance->get('enable_migration_tools', false), |
| 824 | 938 | 'enable_import_export' => (bool) $settings_instance->get('enable_import_export', false), |
| 825 | 939 | 'google_account_connected' => (bool) $settings_instance->get('google_account_connected', false), |
| 826 | 940 | 'enable_mcp' => (bool) $settings_instance->get('enable_mcp', false), |
| 941 | + 'max_requests_per_minute' => (int) $settings_instance->get('max_requests_per_minute', 0), | |
| 942 | + 'ai_daily_request_limit' => (int) $settings_instance->get('ai_daily_request_limit', 0), | |
| 943 | + 'ai_paused' => (bool) $settings_instance->get('ai_paused', false), | |
| 827 | 944 | ]; |
| 828 | 945 | |
| 829 | 946 | |
| 830 | 947 | |
| @@ -841,8 +958,11 @@ | ||
| 841 | 958 | } |
| 842 | 959 | if (!empty($settings['openrouter_api_key'])) { |
| 843 | 960 | $settings['openrouter_api_key'] = $this->mask_ai_api_key($settings['openrouter_api_key']); |
| 844 | 961 | } |
| 962 | + if (!empty($settings['openai_compatible_api_key'])) { | |
| 963 | + $settings['openai_compatible_api_key'] = $this->mask_ai_api_key($settings['openai_compatible_api_key']); | |
| 964 | + } | |
| 845 | 965 | |
| 846 | 966 | return new \WP_REST_Response($settings); |
| 847 | 967 | } |
| 848 | 968 | |
| @@ -880,8 +1000,105 @@ | ||
| 880 | 1000 | // Capture the pre-save MCP state so we can detect an on/off transition |
| 881 | 1001 | // below and mint/revoke the connection token to match (see #244). |
| 882 | 1002 | $mcp_was_enabled = (bool) $settings->get('enable_mcp', false); |
| 883 | 1003 | |
| 1004 | + // Pointing the site's AI at an arbitrary host — including loopback and | |
| 1005 | + // LAN addresses, which this provider deliberately allows — is an | |
| 1006 | + // administrator's decision, not a delegated one. The settings route | |
| 1007 | + // itself is delegable through the Role Manager's `thinkrank_settings` | |
| 1008 | + // capability, so an editor granted "manage ThinkRank settings" could | |
| 1009 | + // otherwise aim server-side requests (with an Authorization header of | |
| 1010 | + // their choosing) at internal services. Every other field on this route | |
| 1011 | + // stays delegable; only these are held back (#721). | |
| 1012 | + $endpoint_fields = [ | |
| 1013 | + 'openai_compatible_base_url', | |
| 1014 | + 'openai_compatible_api_key', | |
| 1015 | + 'openai_compatible_model', | |
| 1016 | + 'openai_compatible_timeout', | |
| 1017 | + 'openai_compatible_supports_images', | |
| 1018 | + 'openai_compatible_json_mode', | |
| 1019 | + 'openai_compatible_price_per_million', | |
| 1020 | + ]; | |
| 1021 | + | |
| 1022 | + foreach ($endpoint_fields as $endpoint_field) { | |
| 1023 | + if (!isset($params[$endpoint_field])) { | |
| 1024 | + continue; | |
| 1025 | + } | |
| 1026 | + | |
| 1027 | + // Only an actual change needs the capability: a client that echoes | |
| 1028 | + // the whole settings payload back unchanged is not reconfiguring | |
| 1029 | + // anything, and failing that save would break the Settings screen | |
| 1030 | + // for delegated users editing an unrelated field. | |
| 1031 | + // | |
| 1032 | + // The key needs the mask rule the persistence loop below already | |
| 1033 | + // uses. GET /settings returns it masked ("sk-pr••••••••abc"), so | |
| 1034 | + // comparing that against the stored plaintext always differs, and | |
| 1035 | + // every echoed payload would read as "an administrator changed the | |
| 1036 | + // key" — locking delegated users out of saving anything at all. | |
| 1037 | + $submitted = $params[$endpoint_field]; | |
| 1038 | + if (is_string($submitted) && false !== strpos($submitted, '••••••••')) { | |
| 1039 | + continue; | |
| 1040 | + } | |
| 1041 | + | |
| 1042 | + $stored = $settings->get($endpoint_field); | |
| 1043 | + | |
| 1044 | + // Booleans and numbers arrive typed from the REST layer but are | |
| 1045 | + // stored as '1'/'' and '120'; compare them as the values they are. | |
| 1046 | + if (is_bool($submitted) || is_bool($stored)) { | |
| 1047 | + if ((bool) $stored === (bool) $submitted) { | |
| 1048 | + continue; | |
| 1049 | + } | |
| 1050 | + } elseif (is_numeric($submitted) && is_numeric($stored)) { | |
| 1051 | + if ((float) $stored === (float) $submitted) { | |
| 1052 | + continue; | |
| 1053 | + } | |
| 1054 | + } elseif ((string) $stored === (string) $submitted) { | |
| 1055 | + continue; | |
| 1056 | + } | |
| 1057 | + | |
| 1058 | + if (!current_user_can('manage_options')) { | |
| 1059 | + return new \WP_REST_Response([ | |
| 1060 | + 'success' => false, | |
| 1061 | + 'message' => __('Only an administrator can configure a custom AI endpoint.', 'thinkrank'), | |
| 1062 | + 'field' => $endpoint_field, | |
| 1063 | + ], 403); | |
| 1064 | + } | |
| 1065 | + | |
| 1066 | + break; | |
| 1067 | + } | |
| 1068 | + | |
| 1069 | + // Selecting the provider is the same decision by another name. | |
| 1070 | + if (isset($params['ai_provider']) | |
| 1071 | + && 'openai_compatible' === $params['ai_provider'] | |
| 1072 | + && 'openai_compatible' !== (string) $settings->get('ai_provider', \ThinkRank\Core\Settings::AI_PROVIDER_NONE) | |
| 1073 | + && !current_user_can('manage_options') | |
| 1074 | + ) { | |
| 1075 | + return new \WP_REST_Response([ | |
| 1076 | + 'success' => false, | |
| 1077 | + 'message' => __('Only an administrator can configure a custom AI endpoint.', 'thinkrank'), | |
| 1078 | + 'field' => 'ai_provider', | |
| 1079 | + ], 403); | |
| 1080 | + } | |
| 1081 | + | |
| 1082 | + // A refused endpoint URL has to say why. Settings::sanitize_setting() | |
| 1083 | + // stores '' for one that fails validation — right, since an unvalidated | |
| 1084 | + // URL must never become a URL we fetch — but silent, so the user would | |
| 1085 | + // see "Settings saved" and an endpoint that vanished. Validate here, | |
| 1086 | + // where the reason can be returned, and reject the whole save: a | |
| 1087 | + // half-applied AI provider is worse than none (#721). | |
| 1088 | + if (!empty($params['openai_compatible_base_url'])) { | |
| 1089 | + $validated_base_url = \ThinkRank\AI\Endpoint_URL_Validator::validate((string) $params['openai_compatible_base_url']); | |
| 1090 | + if (is_wp_error($validated_base_url)) { | |
| 1091 | + return new \WP_REST_Response([ | |
| 1092 | + 'success' => false, | |
| 1093 | + 'message' => $validated_base_url->get_error_message(), | |
| 1094 | + 'field' => 'openai_compatible_base_url', | |
| 1095 | + ], 400); | |
| 1096 | + } | |
| 1097 | + | |
| 1098 | + $params['openai_compatible_base_url'] = $validated_base_url; | |
| 1099 | + } | |
| 1100 | + | |
| 884 | 1101 | // Map frontend parameter names to setting keys |
| 885 | 1102 | $settings_map = [ |
| 886 | 1103 | 'ai_provider' => 'ai_provider', |
| 887 | 1104 | 'openai_api_key' => 'openai_api_key', |
| @@ -891,8 +1108,15 @@ | ||
| 891 | 1108 | 'gemini_api_key' => 'gemini_api_key', |
| 892 | 1109 | 'gemini_model' => 'gemini_model', |
| 893 | 1110 | 'openrouter_api_key' => 'openrouter_api_key', |
| 894 | 1111 | 'openrouter_model' => 'openrouter_model', |
| 1112 | + 'openai_compatible_base_url' => 'openai_compatible_base_url', | |
| 1113 | + 'openai_compatible_api_key' => 'openai_compatible_api_key', | |
| 1114 | + 'openai_compatible_model' => 'openai_compatible_model', | |
| 1115 | + 'openai_compatible_timeout' => 'openai_compatible_timeout', | |
| 1116 | + 'openai_compatible_supports_images' => 'openai_compatible_supports_images', | |
| 1117 | + 'openai_compatible_json_mode' => 'openai_compatible_json_mode', | |
| 1118 | + 'openai_compatible_price_per_million' => 'openai_compatible_price_per_million', | |
| 895 | 1119 | 'max_tokens' => 'max_tokens', |
| 896 | 1120 | 'temperature' => 'temperature', |
| 897 | 1121 | 'cache_duration' => 'cache_duration', |
| 898 | 1122 | 'keep_data_on_uninstall' => 'keep_data_on_uninstall', |
| @@ -898,8 +1122,11 @@ | ||
| 898 | 1122 | 'keep_data_on_uninstall' => 'keep_data_on_uninstall', |
| 899 | 1123 | 'enable_mcp' => 'enable_mcp', |
| 900 | 1124 | 'enable_migration_tools' => 'enable_migration_tools', |
| 901 | 1125 | 'enable_import_export' => 'enable_import_export', |
| 1126 | + 'max_requests_per_minute' => 'max_requests_per_minute', | |
| 1127 | + 'ai_daily_request_limit' => 'ai_daily_request_limit', | |
| 1128 | + 'ai_paused' => 'ai_paused', | |
| 902 | 1129 | ]; |
| 903 | 1130 | |
| 904 | 1131 | // Processing settings save request |
| 905 | 1132 | |
| @@ -907,9 +1134,9 @@ | ||
| 907 | 1134 | if (isset($params[$param_key])) { |
| 908 | 1135 | $value = $params[$param_key]; |
| 909 | 1136 | |
| 910 | 1137 | // Handle API keys specially - check for masked values |
| 911 | - if (in_array($param_key, ['openai_api_key', 'claude_api_key', 'gemini_api_key', 'openrouter_api_key'], true)) { | |
| 1138 | + if (in_array($param_key, ['openai_api_key', 'claude_api_key', 'gemini_api_key', 'openrouter_api_key', 'openai_compatible_api_key'], true)) { | |
| 912 | 1139 | // Don't update if the value carries the mask sentinel (the |
| 913 | 1140 | // preview now keeps real head/tail chars around it, so match |
| 914 | 1141 | // anywhere rather than only at the start). Empty still clears. |
| 915 | 1142 | if (strpos($value, '••••••••') !== false) { |
| @@ -946,9 +1173,9 @@ | ||
| 946 | 1173 | // Auto-dismiss welcome notice if API key was saved |
| 947 | 1174 | $this->maybe_dismiss_welcome_notice($params); |
| 948 | 1175 | |
| 949 | 1176 | // Force AI Manager to re-initialize client with new settings |
| 950 | - if (isset($params['ai_provider']) || isset($params['openai_api_key']) || isset($params['claude_api_key']) || isset($params['gemini_api_key']) || isset($params['openrouter_api_key'])) { | |
| 1177 | + if (isset($params['ai_provider']) || isset($params['openai_api_key']) || isset($params['claude_api_key']) || isset($params['gemini_api_key']) || isset($params['openrouter_api_key']) || isset($params['openai_compatible_base_url']) || isset($params['openai_compatible_api_key']) || isset($params['openai_compatible_model'])) { | |
| 951 | 1178 | // Clear any cached AI Manager instances to force re-initialization |
| 952 | 1179 | wp_cache_delete('thinkrank_ai_manager', 'thinkrank'); |
| 953 | 1180 | |
| 954 | 1181 | // If we have an AI Manager instance, force it to re-initialize |
| @@ -1056,9 +1283,9 @@ | ||
| 1056 | 1283 | // Rate limiting: per user/IP per route |
| 1057 | 1284 | $user_id = get_current_user_id(); |
| 1058 | 1285 | $ip = isset($_SERVER['REMOTE_ADDR']) ? sanitize_text_field(wp_unslash($_SERVER['REMOTE_ADDR'])) : 'unknown'; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput |
| 1059 | 1286 | $bucket_id = 'ai_generate|' . ($user_id ?: $ip); |
| 1060 | - $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 10); | |
| 1287 | + $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 0); | |
| 1061 | 1288 | $allowed = $this->enforce_rate_limit($bucket_id, $limit); |
| 1062 | 1289 | if (is_wp_error($allowed)) { |
| 1063 | 1290 | return new \WP_REST_Response([ |
| 1064 | 1291 | 'success' => false, |
| @@ -1110,9 +1337,9 @@ | ||
| 1110 | 1337 | // Rate limiting: shares the AI generation bucket. |
| 1111 | 1338 | $user_id = get_current_user_id(); |
| 1112 | 1339 | $ip = isset($_SERVER['REMOTE_ADDR']) ? sanitize_text_field(wp_unslash($_SERVER['REMOTE_ADDR'])) : 'unknown'; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput |
| 1113 | 1340 | $bucket_id = 'ai_generate|' . ($user_id ?: $ip); |
| 1114 | - $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 10); | |
| 1341 | + $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 0); | |
| 1115 | 1342 | $allowed = $this->enforce_rate_limit($bucket_id, $limit); |
| 1116 | 1343 | if (is_wp_error($allowed)) { |
| 1117 | 1344 | return new \WP_REST_Response([ |
| 1118 | 1345 | 'success' => false, |
| @@ -1160,9 +1387,9 @@ | ||
| 1160 | 1387 | // Rate limiting: shares the AI generation bucket. |
| 1161 | 1388 | $user_id = get_current_user_id(); |
| 1162 | 1389 | $ip = isset($_SERVER['REMOTE_ADDR']) ? sanitize_text_field(wp_unslash($_SERVER['REMOTE_ADDR'])) : 'unknown'; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput |
| 1163 | 1390 | $bucket_id = 'ai_generate|' . ($user_id ?: $ip); |
| 1164 | - $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 10); | |
| 1391 | + $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 0); | |
| 1165 | 1392 | $allowed = $this->enforce_rate_limit($bucket_id, $limit); |
| 1166 | 1393 | if (is_wp_error($allowed)) { |
| 1167 | 1394 | return new \WP_REST_Response([ |
| 1168 | 1395 | 'success' => false, |
| @@ -1212,9 +1439,9 @@ | ||
| 1212 | 1439 | // Rate limiting: shares the AI generation bucket. |
| 1213 | 1440 | $user_id = get_current_user_id(); |
| 1214 | 1441 | $ip = isset($_SERVER['REMOTE_ADDR']) ? sanitize_text_field(wp_unslash($_SERVER['REMOTE_ADDR'])) : 'unknown'; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput |
| 1215 | 1442 | $bucket_id = 'ai_generate|' . ($user_id ?: $ip); |
| 1216 | - $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 10); | |
| 1443 | + $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 0); | |
| 1217 | 1444 | $allowed = $this->enforce_rate_limit($bucket_id, $limit); |
| 1218 | 1445 | if (is_wp_error($allowed)) { |
| 1219 | 1446 | return new \WP_REST_Response([ |
| 1220 | 1447 | 'success' => false, |
| @@ -1258,9 +1485,9 @@ | ||
| 1258 | 1485 | // Rate limiting: shares the AI generation bucket. |
| 1259 | 1486 | $user_id = get_current_user_id(); |
| 1260 | 1487 | $ip = isset($_SERVER['REMOTE_ADDR']) ? sanitize_text_field(wp_unslash($_SERVER['REMOTE_ADDR'])) : 'unknown'; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput |
| 1261 | 1488 | $bucket_id = 'ai_generate|' . ($user_id ?: $ip); |
| 1262 | - $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 10); | |
| 1489 | + $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 0); | |
| 1263 | 1490 | $allowed = $this->enforce_rate_limit($bucket_id, $limit); |
| 1264 | 1491 | if (is_wp_error($allowed)) { |
| 1265 | 1492 | return new \WP_REST_Response([ |
| 1266 | 1493 | 'success' => false, |
| @@ -1307,9 +1534,9 @@ | ||
| 1307 | 1534 | // Rate limiting: shares the AI generation bucket. |
| 1308 | 1535 | $user_id = get_current_user_id(); |
| 1309 | 1536 | $ip = isset($_SERVER['REMOTE_ADDR']) ? sanitize_text_field(wp_unslash($_SERVER['REMOTE_ADDR'])) : 'unknown'; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput |
| 1310 | 1537 | $bucket_id = 'ai_generate|' . ($user_id ?: $ip); |
| 1311 | - $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 10); | |
| 1538 | + $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 0); | |
| 1312 | 1539 | $allowed = $this->enforce_rate_limit($bucket_id, $limit); |
| 1313 | 1540 | if (is_wp_error($allowed)) { |
| 1314 | 1541 | return new \WP_REST_Response([ |
| 1315 | 1542 | 'success' => false, |
| @@ -1406,9 +1633,9 @@ | ||
| 1406 | 1633 | // Rate limiting: per user/IP per route |
| 1407 | 1634 | $user_id = get_current_user_id(); |
| 1408 | 1635 | $ip = isset($_SERVER['REMOTE_ADDR']) ? sanitize_text_field(wp_unslash($_SERVER['REMOTE_ADDR'])) : 'unknown'; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput |
| 1409 | 1636 | $bucket_id = 'ai_test|' . ($user_id ?: $ip); |
| 1410 | - $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 10); | |
| 1637 | + $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 0); | |
| 1411 | 1638 | $allowed = $this->enforce_rate_limit($bucket_id, $limit); |
| 1412 | 1639 | if (is_wp_error($allowed)) { |
| 1413 | 1640 | return new \WP_REST_Response([ |
| 1414 | 1641 | 'success' => false, |
| @@ -1434,8 +1661,34 @@ | ||
| 1434 | 1661 | 'message' => sprintf(__('Unknown AI provider: %s', 'thinkrank'), $provider), |
| 1435 | 1662 | ], 400); |
| 1436 | 1663 | } |
| 1437 | 1664 | |
| 1665 | + // The OpenAI-compatible endpoint is tested by URL, not by key: a | |
| 1666 | + // local Ollama or LM Studio server wants no key, so the key checks | |
| 1667 | + // below would refuse to test a perfectly good endpoint (#721). | |
| 1668 | + if ('openai_compatible' === $provider) { | |
| 1669 | + $base_url = trim((string) $request->get_param('base_url')); | |
| 1670 | + if ('' === $base_url) { | |
| 1671 | + $base_url = (string) \ThinkRank\Core\Settings::instance()->get('openai_compatible_base_url', ''); | |
| 1672 | + } | |
| 1673 | + | |
| 1674 | + if (empty($api_key)) { | |
| 1675 | + $api_key = (string) \ThinkRank\Core\Settings::instance()->get('openai_compatible_api_key', ''); | |
| 1676 | + } | |
| 1677 | + | |
| 1678 | + if ('' === $model) { | |
| 1679 | + $model = trim((string) \ThinkRank\Core\Settings::instance()->get('openai_compatible_model', '')); | |
| 1680 | + } | |
| 1681 | + | |
| 1682 | + $json_mode = $request->has_param('json_mode') | |
| 1683 | + ? (bool) $request->get_param('json_mode') | |
| 1684 | + : (bool) \ThinkRank\Core\Settings::instance()->get('openai_compatible_json_mode', false); | |
| 1685 | + | |
| 1686 | + $result = $this->test_openai_compatible_connection($base_url, $api_key, $model, $json_mode); | |
| 1687 | + | |
| 1688 | + return new \WP_REST_Response($result, $result['success'] ? 200 : 400); | |
| 1689 | + } | |
| 1690 | + | |
| 1438 | 1691 | // If no API key provided in request, try to get from saved settings |
| 1439 | 1692 | if (empty($api_key)) { |
| 1440 | 1693 | $settings = \ThinkRank\Core\Settings::instance(); |
| 1441 | 1694 | if ($provider === 'openai') { |
| @@ -1476,8 +1729,363 @@ | ||
| 1476 | 1729 | } |
| 1477 | 1730 | } |
| 1478 | 1731 | |
| 1479 | 1732 | /** |
| 1733 | + * Test an OpenAI-compatible endpoint with a real (tiny) completion. | |
| 1734 | + * | |
| 1735 | + * Deliberately not a GET /models probe: a server can list models and still | |
| 1736 | + * fail to complete (wrong model id, model not pulled, gateway that only | |
| 1737 | + * proxies /models). The one-token chat completion answers the question the | |
| 1738 | + * user is actually asking — "can ThinkRank generate with this?" — and its | |
| 1739 | + * reply plus latency is what the settings screen shows (#721). | |
| 1740 | + * | |
| 1741 | + * @since 2.8.0 | |
| 1742 | + * | |
| 1743 | + * @param string $base_url Base URL as typed (validated here). | |
| 1744 | + * @param string $api_key Optional API key. | |
| 1745 | + * @param string $model Model id to complete with. | |
| 1746 | + * @param bool $json_mode Also check the server accepts response_format json_object. | |
| 1747 | + * @return array Test result. | |
| 1748 | + */ | |
| 1749 | + private function test_openai_compatible_connection(string $base_url, string $api_key, string $model, bool $json_mode = false): array { | |
| 1750 | + $validated = \ThinkRank\AI\Endpoint_URL_Validator::validate($base_url); | |
| 1751 | + if (is_wp_error($validated)) { | |
| 1752 | + return [ | |
| 1753 | + 'success' => false, | |
| 1754 | + 'message' => $validated->get_error_message(), | |
| 1755 | + ]; | |
| 1756 | + } | |
| 1757 | + | |
| 1758 | + if ('' === trim($model)) { | |
| 1759 | + return [ | |
| 1760 | + 'success' => false, | |
| 1761 | + 'message' => __('Enter the model id your endpoint should use, for example llama3.1 or gpt-4o.', 'thinkrank'), | |
| 1762 | + ]; | |
| 1763 | + } | |
| 1764 | + | |
| 1765 | + $headers = ['Content-Type' => 'application/json']; | |
| 1766 | + if ('' !== $api_key) { | |
| 1767 | + $headers['Authorization'] = 'Bearer ' . $api_key; | |
| 1768 | + $headers['api-key'] = $api_key; | |
| 1769 | + } | |
| 1770 | + | |
| 1771 | + // A "Reply with OK" answer is tiny; anything approaching this is a | |
| 1772 | + // server misbehaving, and the guard caps it before it is buffered. | |
| 1773 | + $max_bytes = 131072; | |
| 1774 | + | |
| 1775 | + $started = microtime(true); | |
| 1776 | + | |
| 1777 | + $response = \ThinkRank\AI\Endpoint_URL_Validator::guarded_request(\ThinkRank\AI\Endpoint_URL_Validator::route($validated, 'chat/completions'), [ | |
| 1778 | + 'method' => 'POST', | |
| 1779 | + // Long enough for a cold local model to load its weights, short | |
| 1780 | + // enough that a wrong URL does not hang the settings screen. | |
| 1781 | + 'timeout' => 30, | |
| 1782 | + 'headers' => $headers, | |
| 1783 | + 'limit_response_size' => $max_bytes, | |
| 1784 | + 'body' => wp_json_encode([ | |
| 1785 | + 'model' => trim($model), | |
| 1786 | + 'messages' => [['role' => 'user', 'content' => 'Reply with OK']], | |
| 1787 | + // Not 16: a local reasoning model (deepseek-r1, a qwen3 | |
| 1788 | + // thinking build) spends its first tokens on hidden reasoning | |
| 1789 | + // and returns empty content if the budget runs out there, which | |
| 1790 | + // would report a working endpoint as broken. | |
| 1791 | + 'max_tokens' => 128, | |
| 1792 | + ]), | |
| 1793 | + ]); | |
| 1794 | + | |
| 1795 | + $latency_ms = (int) round((microtime(true) - $started) * 1000); | |
| 1796 | + | |
| 1797 | + if (is_wp_error($response)) { | |
| 1798 | + return [ | |
| 1799 | + 'success' => false, | |
| 1800 | + /* translators: %s: transport error, e.g. "cURL error 7: Connection refused". */ | |
| 1801 | + 'message' => sprintf(__('Could not reach the endpoint: %s', 'thinkrank'), $response->get_error_message()), | |
| 1802 | + ]; | |
| 1803 | + } | |
| 1804 | + | |
| 1805 | + $status = (int) wp_remote_retrieve_response_code($response); | |
| 1806 | + $raw_body = wp_remote_retrieve_body($response); | |
| 1807 | + | |
| 1808 | + // Redirects are never followed (the key would go wherever the endpoint | |
| 1809 | + // points). Say so, rather than letting the empty 3xx body read as a | |
| 1810 | + // wrong model id: an http-to-https upgrade is the usual cause. | |
| 1811 | + if ($status >= 300 && $status < 400) { | |
| 1812 | + $location = (string) wp_remote_retrieve_header($response, 'location'); | |
| 1813 | + | |
| 1814 | + return [ | |
| 1815 | + 'success' => false, | |
| 1816 | + 'status' => $status, | |
| 1817 | + 'message' => '' !== $location | |
| 1818 | + ? sprintf( | |
| 1819 | + /* translators: 1: HTTP status code, 2: the URL the endpoint redirected to. */ | |
| 1820 | + __('The endpoint redirected (%1$d) to %2$s. Redirects are refused so your API key cannot follow them. Enter the final URL instead, for example https:// in place of http://.', 'thinkrank'), | |
| 1821 | + $status, | |
| 1822 | + esc_url_raw($location) | |
| 1823 | + ) | |
| 1824 | + : sprintf( | |
| 1825 | + /* translators: %d: HTTP status code. */ | |
| 1826 | + __('The endpoint redirected (%d). Redirects are refused so your API key cannot follow them. Enter the final URL instead, for example https:// in place of http://.', 'thinkrank'), | |
| 1827 | + $status | |
| 1828 | + ), | |
| 1829 | + ]; | |
| 1830 | + } | |
| 1831 | + | |
| 1832 | + // A body that reached the cap was cut mid-JSON. Report that, not a | |
| 1833 | + // missing completion: the model id was never the problem. | |
| 1834 | + if (strlen($raw_body) >= $max_bytes) { | |
| 1835 | + return [ | |
| 1836 | + 'success' => false, | |
| 1837 | + 'status' => $status, | |
| 1838 | + 'message' => __('The endpoint sent more than ThinkRank will read for a connection test (128 KB). It is misconfigured or is not answering with a chat completion.', 'thinkrank'), | |
| 1839 | + ]; | |
| 1840 | + } | |
| 1841 | + | |
| 1842 | + $body = json_decode($raw_body, true); | |
| 1843 | + | |
| 1844 | + if ($status >= 400) { | |
| 1845 | + $error = ''; | |
| 1846 | + if (is_array($body)) { | |
| 1847 | + $error = (string) ($body['error']['message'] ?? ($body['error'] ?? ($body['message'] ?? ''))); | |
| 1848 | + } | |
| 1849 | + if ('' === $error) { | |
| 1850 | + $error = wp_remote_retrieve_response_message($response); | |
| 1851 | + } | |
| 1852 | + | |
| 1853 | + return [ | |
| 1854 | + 'success' => false, | |
| 1855 | + 'status' => $status, | |
| 1856 | + /* translators: 1: HTTP status code, 2: error message from the server. */ | |
| 1857 | + 'message' => sprintf(__('The endpoint answered %1$d: %2$s', 'thinkrank'), $status, $error), | |
| 1858 | + ]; | |
| 1859 | + } | |
| 1860 | + | |
| 1861 | + $reply = ''; | |
| 1862 | + $reasoning_only = false; | |
| 1863 | + if (is_array($body)) { | |
| 1864 | + $message = is_array($body['choices'][0]['message'] ?? null) ? $body['choices'][0]['message'] : []; | |
| 1865 | + $reply = trim((string) ($message['content'] ?? '')); | |
| 1866 | + | |
| 1867 | + // Ollama and vLLM expose a thinking model's hidden reasoning | |
| 1868 | + // separately. Reasoning with no content still proves the endpoint | |
| 1869 | + // and the model work — it means the model thinks before answering, | |
| 1870 | + // which is worth saying out loud because it makes every generation | |
| 1871 | + // slower. | |
| 1872 | + if ('' === $reply) { | |
| 1873 | + $reasoning = trim((string) ($message['reasoning'] ?? ($message['reasoning_content'] ?? ''))); | |
| 1874 | + if ('' !== $reasoning) { | |
| 1875 | + $reply = $reasoning; | |
| 1876 | + $reasoning_only = true; | |
| 1877 | + } | |
| 1878 | + } | |
| 1879 | + } | |
| 1880 | + | |
| 1881 | + if ('' === $reply) { | |
| 1882 | + return [ | |
| 1883 | + 'success' => false, | |
| 1884 | + 'status' => $status, | |
| 1885 | + 'message' => __('The endpoint replied, but with no completion text. Check that the model id is one this server serves.', 'thinkrank'), | |
| 1886 | + ]; | |
| 1887 | + } | |
| 1888 | + | |
| 1889 | + $result = [ | |
| 1890 | + 'success' => true, | |
| 1891 | + 'model' => trim($model), | |
| 1892 | + 'model_available' => true, | |
| 1893 | + 'latency_ms' => $latency_ms, | |
| 1894 | + 'reply' => mb_substr($reply, 0, 200), | |
| 1895 | + 'reasoning_only' => $reasoning_only, | |
| 1896 | + 'message' => $reasoning_only | |
| 1897 | + ? sprintf( | |
| 1898 | + /* translators: 1: model id, 2: latency in milliseconds. */ | |
| 1899 | + __('Connected: "%1$s" answered in %2$d ms. It is a reasoning model: it thinks before replying, so generation will be slower and may need a higher timeout.', 'thinkrank'), | |
| 1900 | + trim($model), | |
| 1901 | + $latency_ms | |
| 1902 | + ) | |
| 1903 | + : sprintf( | |
| 1904 | + /* translators: 1: model id, 2: latency in milliseconds, 3: the model's reply. */ | |
| 1905 | + __('Connected: "%1$s" replied in %2$d ms: %3$s', 'thinkrank'), | |
| 1906 | + trim($model), | |
| 1907 | + $latency_ms, | |
| 1908 | + mb_substr($reply, 0, 80) | |
| 1909 | + ), | |
| 1910 | + ]; | |
| 1911 | + | |
| 1912 | + return $json_mode | |
| 1913 | + ? $this->probe_openai_compatible_json_mode($validated, $headers, trim($model), $result) | |
| 1914 | + : $result; | |
| 1915 | + } | |
| 1916 | + | |
| 1917 | + /** | |
| 1918 | + * Check that an endpoint takes response_format json_object. | |
| 1919 | + * | |
| 1920 | + * Runs only after the plain completion worked, so a failure here can mean | |
| 1921 | + * one thing: the endpoint works, but not with "Force valid JSON answers" | |
| 1922 | + * on. Generation still works then, because OpenAI_Client falls back to a | |
| 1923 | + * plain request, but every JSON call pays a failed round trip first. The | |
| 1924 | + * connection stays a success; the result carries json_mode_supported so | |
| 1925 | + * the screen can warn instead of reporting a broken endpoint. | |
| 1926 | + * | |
| 1927 | + * @since 2.8.0 | |
| 1928 | + * | |
| 1929 | + * @param string $base_url Validated base URL. | |
| 1930 | + * @param array $headers Request headers, key included. | |
| 1931 | + * @param string $model Model id. | |
| 1932 | + * @param array $result Successful connection result to extend. | |
| 1933 | + * @return array The result, with json_mode_supported and, when false, a warning message. | |
| 1934 | + */ | |
| 1935 | + private function probe_openai_compatible_json_mode(string $base_url, array $headers, string $model, array $result): array { | |
| 1936 | + $response = \ThinkRank\AI\Endpoint_URL_Validator::guarded_request(\ThinkRank\AI\Endpoint_URL_Validator::route($base_url, 'chat/completions'), [ | |
| 1937 | + 'method' => 'POST', | |
| 1938 | + 'timeout' => 30, | |
| 1939 | + 'headers' => $headers, | |
| 1940 | + 'limit_response_size' => 131072, | |
| 1941 | + 'body' => wp_json_encode([ | |
| 1942 | + 'model' => $model, | |
| 1943 | + // OpenAI refuses json_object unless the messages mention JSON. | |
| 1944 | + 'messages' => [['role' => 'user', 'content' => 'Reply with the JSON object {"ok": true}']], | |
| 1945 | + 'max_tokens' => 128, | |
| 1946 | + 'response_format' => ['type' => 'json_object'], | |
| 1947 | + ]), | |
| 1948 | + ]); | |
| 1949 | + | |
| 1950 | + // A timeout or dropped connection says nothing about JSON mode. Leave | |
| 1951 | + // the result alone rather than warn about a field that was never judged. | |
| 1952 | + if (is_wp_error($response)) { | |
| 1953 | + return $result; | |
| 1954 | + } | |
| 1955 | + | |
| 1956 | + $status = (int) wp_remote_retrieve_response_code($response); | |
| 1957 | + if ($status < 400) { | |
| 1958 | + $result['json_mode_supported'] = true; | |
| 1959 | + return $result; | |
| 1960 | + } | |
| 1961 | + | |
| 1962 | + $body = json_decode((string) wp_remote_retrieve_body($response), true); | |
| 1963 | + $error = ''; | |
| 1964 | + if (is_array($body)) { | |
| 1965 | + // OpenAI and vLLM nest the text under error.message; Ollama sends a bare error string. | |
| 1966 | + $error = is_string($body['error'] ?? null) | |
| 1967 | + ? $body['error'] | |
| 1968 | + : (string) ($body['error']['message'] ?? ($body['message'] ?? '')); | |
| 1969 | + } | |
| 1970 | + if ('' === $error) { | |
| 1971 | + $error = (string) wp_remote_retrieve_response_message($response); | |
| 1972 | + } | |
| 1973 | + | |
| 1974 | + $result['json_mode_supported'] = false; | |
| 1975 | + $result['message'] = sprintf( | |
| 1976 | + /* translators: 1: model id, 2: HTTP status code, 3: error message from the server. */ | |
| 1977 | + __('Connected to "%1$s", but the endpoint rejected JSON mode (%2$d: %3$s). Turn off "Force valid JSON answers": generation still works, but each request is sent twice.', 'thinkrank'), | |
| 1978 | + $model, | |
| 1979 | + $status, | |
| 1980 | + $error | |
| 1981 | + ); | |
| 1982 | + | |
| 1983 | + return $result; | |
| 1984 | + } | |
| 1985 | + | |
| 1986 | + /** | |
| 1987 | + * List the models an OpenAI-compatible endpoint serves. | |
| 1988 | + * | |
| 1989 | + * @since 2.8.0 | |
| 1990 | + * | |
| 1991 | + * @param \WP_REST_Request $request Request object. | |
| 1992 | + * @return \WP_REST_Response Response object. | |
| 1993 | + */ | |
| 1994 | + public function list_endpoint_models(\WP_REST_Request $request): \WP_REST_Response { | |
| 1995 | + $settings = \ThinkRank\Core\Settings::instance(); | |
| 1996 | + | |
| 1997 | + $base_url = trim((string) $request->get_param('base_url')); | |
| 1998 | + if ('' === $base_url) { | |
| 1999 | + $base_url = (string) $settings->get('openai_compatible_base_url', ''); | |
| 2000 | + } | |
| 2001 | + | |
| 2002 | + $validated = \ThinkRank\AI\Endpoint_URL_Validator::validate($base_url); | |
| 2003 | + if (is_wp_error($validated)) { | |
| 2004 | + return new \WP_REST_Response([ | |
| 2005 | + 'success' => false, | |
| 2006 | + 'message' => $validated->get_error_message(), | |
| 2007 | + ], 400); | |
| 2008 | + } | |
| 2009 | + | |
| 2010 | + $api_key = trim((string) $request->get_param('api_key')); | |
| 2011 | + if ('' === $api_key || false !== strpos($api_key, '••••••••')) { | |
| 2012 | + $api_key = (string) $settings->get('openai_compatible_api_key', ''); | |
| 2013 | + } | |
| 2014 | + | |
| 2015 | + $headers = ['Content-Type' => 'application/json']; | |
| 2016 | + if ('' !== $api_key) { | |
| 2017 | + $headers['Authorization'] = 'Bearer ' . $api_key; | |
| 2018 | + $headers['api-key'] = $api_key; | |
| 2019 | + } | |
| 2020 | + | |
| 2021 | + $response = \ThinkRank\AI\Endpoint_URL_Validator::guarded_request(\ThinkRank\AI\Endpoint_URL_Validator::route($validated, 'models'), [ | |
| 2022 | + 'method' => 'GET', | |
| 2023 | + 'timeout' => 15, | |
| 2024 | + 'headers' => $headers, | |
| 2025 | + // A hostile or misconfigured endpoint can answer with an unbounded | |
| 2026 | + // body; buffering it whole would spend the worker's memory on a | |
| 2027 | + // list we cap at MAX_ENDPOINT_MODELS anyway. | |
| 2028 | + 'limit_response_size' => self::MAX_MODELS_RESPONSE_BYTES, | |
| 2029 | + ]); | |
| 2030 | + | |
| 2031 | + if (is_wp_error($response)) { | |
| 2032 | + return new \WP_REST_Response([ | |
| 2033 | + 'success' => false, | |
| 2034 | + /* translators: %s: transport error. */ | |
| 2035 | + 'message' => sprintf(__('Could not reach the endpoint: %s', 'thinkrank'), $response->get_error_message()), | |
| 2036 | + ], 400); | |
| 2037 | + } | |
| 2038 | + | |
| 2039 | + $status = (int) wp_remote_retrieve_response_code($response); | |
| 2040 | + $body = json_decode(wp_remote_retrieve_body($response), true); | |
| 2041 | + | |
| 2042 | + if ($status >= 400 || !is_array($body)) { | |
| 2043 | + return new \WP_REST_Response([ | |
| 2044 | + 'success' => false, | |
| 2045 | + /* translators: %d: HTTP status code. */ | |
| 2046 | + 'message' => sprintf(__('This endpoint does not list its models (HTTP %d). Type the model id by hand instead.', 'thinkrank'), $status), | |
| 2047 | + ], 400); | |
| 2048 | + } | |
| 2049 | + | |
| 2050 | + // OpenAI's shape is {data: [{id: …}]}; some gateways answer a bare list. | |
| 2051 | + $entries = isset($body['data']) && is_array($body['data']) ? $body['data'] : $body; | |
| 2052 | + $models = []; | |
| 2053 | + $truncated = false; | |
| 2054 | + foreach ($entries as $entry) { | |
| 2055 | + if (count($models) >= self::MAX_ENDPOINT_MODELS) { | |
| 2056 | + // A gateway fronting a public catalogue can list thousands of | |
| 2057 | + // models. Sanitising and sorting all of them is work nobody | |
| 2058 | + // asked for — the field is a suggestion list, not a registry. | |
| 2059 | + $truncated = true; | |
| 2060 | + break; | |
| 2061 | + } | |
| 2062 | + | |
| 2063 | + if (is_array($entry) && !empty($entry['id'])) { | |
| 2064 | + $models[] = sanitize_text_field((string) $entry['id']); | |
| 2065 | + } elseif (is_string($entry) && '' !== $entry) { | |
| 2066 | + $models[] = sanitize_text_field($entry); | |
| 2067 | + } | |
| 2068 | + } | |
| 2069 | + | |
| 2070 | + $models = array_values(array_unique($models)); | |
| 2071 | + sort($models); | |
| 2072 | + | |
| 2073 | + if (empty($models)) { | |
| 2074 | + return new \WP_REST_Response([ | |
| 2075 | + 'success' => false, | |
| 2076 | + 'message' => __('The endpoint answered, but listed no models. Type the model id by hand instead.', 'thinkrank'), | |
| 2077 | + ], 400); | |
| 2078 | + } | |
| 2079 | + | |
| 2080 | + return new \WP_REST_Response([ | |
| 2081 | + 'success' => true, | |
| 2082 | + 'models' => $models, | |
| 2083 | + 'truncated' => $truncated, | |
| 2084 | + ]); | |
| 2085 | + } | |
| 2086 | + | |
| 2087 | + /** | |
| 1480 | 2088 | * Test OpenAI API connection |
| 1481 | 2089 | * |
| 1482 | 2090 | * The models endpoint doubles as the model check: it answers with every id |
| 1483 | 2091 | * this key may call, so an unknown or unentitled model is caught here |
| @@ -1873,8 +2481,14 @@ | ||
| 1873 | 2481 | public function get_ai_status(\WP_REST_Request $request): \WP_REST_Response { |
| 1874 | 2482 | $ai_manager = new \ThinkRank\AI\Manager(); |
| 1875 | 2483 | $status = $ai_manager->get_provider_status(); |
| 1876 | 2484 | |
| 2485 | + // The spend ceiling and kill switch ride on the status the AI screen | |
| 2486 | + // already polls, rather than a route of their own: a counter the user | |
| 2487 | + // has to refresh separately to trust is a counter they will not trust | |
| 2488 | + // (#448). | |
| 2489 | + $status['budget'] = \ThinkRank\AI\Spend_Guard::status(); | |
| 2490 | + | |
| 1877 | 2491 | return new \WP_REST_Response($status); |
| 1878 | 2492 | } |
| 1879 | 2493 | |
| 1880 | 2494 | /** |
| @@ -1892,9 +2506,9 @@ | ||
| 1892 | 2506 | // Rate limiting: per user/IP per route |
| 1893 | 2507 | $user_id = get_current_user_id(); |
| 1894 | 2508 | $ip = isset($_SERVER['REMOTE_ADDR']) ? sanitize_text_field(wp_unslash($_SERVER['REMOTE_ADDR'])) : 'unknown'; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput |
| 1895 | 2509 | $bucket_id = 'ai_analyze|' . ($user_id ?: $ip); |
| 1896 | - $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 10); | |
| 2510 | + $limit = (int) \ThinkRank\Core\Settings::instance()->get('max_requests_per_minute', 0); | |
| 1897 | 2511 | $allowed = $this->enforce_rate_limit($bucket_id, $limit); |
| 1898 | 2512 | if (is_wp_error($allowed)) { |
| 1899 | 2513 | return new \WP_REST_Response([ |
| 1900 | 2514 | 'success' => false, |
| @@ -1975,15 +2589,8 @@ | ||
| 1975 | 2589 | // Failed to register AI Insights endpoint |
| 1976 | 2590 | } |
| 1977 | 2591 | |
| 1978 | 2592 | try { |
| 1979 | - $brand_visibility_endpoint = new Brand_Visibility_Endpoint(); | |
| 1980 | - $brand_visibility_endpoint->register_routes(); | |
| 1981 | - } catch (\Exception $e) { | |
| 1982 | - // Failed to register Brand Visibility endpoint | |
| 1983 | - } | |
| 1984 | - | |
| 1985 | - try { | |
| 1986 | 2593 | $performance_endpoint = new Performance_Endpoint(); |
| 1987 | 2594 | $performance_endpoint->register_routes(); |
| 1988 | 2595 | } catch (\Exception $e) { |
| 1989 | 2596 | // Failed to register Performance endpoint |
| @@ -2056,8 +2663,26 @@ | ||
| 2056 | 2663 | $content_type_matrix_endpoint = new \ThinkRank\API\Content_Type_Matrix_Endpoint(); |
| 2057 | 2664 | $content_type_matrix_endpoint->register_routes(); |
| 2058 | 2665 | } catch (\Exception $e) { |
| 2059 | 2666 | // Failed to register Content Type Matrix endpoint |
| 2667 | + } | |
| 2668 | + | |
| 2669 | + try { | |
| 2670 | + // Bulk Snippets (#727): lives under global-seo/, so the Role | |
| 2671 | + // Manager's Bulk SEO Optimization capability covers it. | |
| 2672 | + $snippets_endpoint = new \ThinkRank\API\Snippets_Endpoint(); | |
| 2673 | + $snippets_endpoint->register_routes(); | |
| 2674 | + } catch (\Exception $e) { | |
| 2675 | + // Failed to register Bulk Snippets endpoint | |
| 2676 | + } | |
| 2677 | + | |
| 2678 | + try { | |
| 2679 | + // Thin content report (#565): also under global-seo/, so the same | |
| 2680 | + // Bulk SEO Optimization capability covers it. | |
| 2681 | + $thin_content_endpoint = new \ThinkRank\API\Thin_Content_Endpoint(); | |
| 2682 | + $thin_content_endpoint->register_routes(); | |
| 2683 | + } catch (\Exception $e) { | |
| 2684 | + // Failed to register Thin Content endpoint | |
| 2060 | 2685 | } |
| 2061 | 2686 | |
| 2062 | 2687 | try { |
| 2063 | 2688 | $image_seo_endpoint = new Image_SEO_Endpoint(); |
