Changeset 3778598

Timestamp:

11/01/2026 09:58:19 PM (2 hours ago)

Author:

kognetiks

Message:

2.5.5 - Released 2026-11-01

### Bug Fixes

• Anthropic replies: Current Claude models can return a thinking block before the answer. The plugin read only the first block, so a successful reply was replaced with a generic API error. Replies are now taken from the text blocks. Haiku 5.5, Sonnet 5, and Opus 5 turn thinking off so the token cap is available for the answer. Sonnet 5.5 uses between-tools thinking, which does not spend that cap before a normal chat reply.
• Anthropic output limit: Opus 5.5 and Fable keep thinking on, and those thinking tokens count against the max tokens setting. A setting below 4,000 is sent as 4,000 for those models. If the model still uses the whole cap before it writes a reply, the chatbot names the model and asks you to increase the Anthropic max tokens setting.

Location:

chatbot-chatgpt/trunk

Files:

• CHANGELOG.md (modified) (1 diff)
• SECURITY.md (modified) (1 diff)
• chatbot-chatgpt.php (modified) (3 diffs)
• documentation/overview.md (modified) (1 diff)
• documentation/specs/functional-details.md (modified) (2 diffs)
• documentation/updates/updates.md (modified) (1 diff)
• includes/chatbot-call-anthropic-api.php (modified) (3 diffs)
• includes/settings/chatbot-settings-api-test.php (modified) (3 diffs)
• includes/utilities/chatbot-models.php (modified) (1 diff)
• readme.txt (modified) (2 diffs)

chatbot-chatgpt/trunk/CHANGELOG.md

@@ -6 +6 @@
 
 ---
+
+= 2.5.5 - Released 2026-11-01 =
+
+### Bug Fixes
+* **Anthropic replies**: Current Claude models can return a thinking block before the answer. The plugin read only the first block, so a successful reply was replaced with a generic API error. Replies are now taken from the text blocks. Haiku 5.5, Sonnet 5, and Opus 5 turn thinking off so the token cap is available for the answer. Sonnet 5.5 uses between-tools thinking, which does not spend that cap before a normal chat reply.
+* **Anthropic output limit**: Opus 5.5 and Fable keep thinking on, and those thinking tokens count against the max tokens setting. A setting below 4,000 is sent as 4,000 for those models. If the model still uses the whole cap before it writes a reply, the chatbot names the model and asks you to increase the Anthropic max tokens setting.
+
+= 2.5.4 - Released 2026-10-31 =
+
+### Bug Fixes
+* **Anthropic model list**: The Anthropic model list had become stale. It is now refreshed from the API.
 
 = 2.5.3 - Released 2026-10-29 =

chatbot-chatgpt/trunk/SECURITY.md

@@ -5 +5 @@
 | Version   | Supported          |
 |-----------|--------------------|
-|   2.5.4   | :white_check_mark: |
-| < 2.5.4   | :x:                |
+|   2.5.5   | :white_check_mark: |
+| < 2.5.5   | :x:                |
 
 ## Reporting a Vulnerability

chatbot-chatgpt/trunk/chatbot-chatgpt.php

@@ -5 +5 @@
  * Plugin URI:  https://github.com/kognetiks/kognetiks-chatbot
  * Description: This simple plugin adds an AI powered chatbot to your WordPress website.
- * Version:     2.5.4
+ * Version:     2.5.5
  * Author:      Kognetiks.com
  * Author URI:  https://www.kognetiks.com
@@ -30 +30 @@
  * 
  * @package chatbot-chatgpt
- * @version 2.5.4
+ * @version 2.5.5
  * @author Kognetiks.com
  */
@@ -85 +85 @@
     // Plugin version
     global $chatbot_chatgpt_plugin_version;
-    $chatbot_chatgpt_plugin_version = '2.5.4';
+    $chatbot_chatgpt_plugin_version = '2.5.5';
     // Plugin directory path
     global $chatbot_chatgpt_plugin_dir_path;

chatbot-chatgpt/trunk/documentation/overview.md

@@ -45 +45 @@
 The **Kognetiks Chatbot** plugin now includes a novel feature: the Sentential Context Model.  This new **beta feature** allows the chatbot to generate intelligent responses by leveraging your website's content - no AI platform connection required.  It's perfect for localized use or content-focused applications, this feature makes the chatbot more versatile than ever.
 
-## What's new in Version 2.5.4 - Released TBD
+## What's new in Version 2.5.5 - Released 2026-11-01
 
 ### Bug Fixes
-* **TBD**: TBD
+* **Anthropic replies**: Current Claude models can return a thinking block before the answer. The plugin read only the first block, so a successful reply was replaced with a generic API error. Replies are now taken from the text blocks. Haiku 5.5, Sonnet 5, and Opus 5 turn thinking off so the token cap is available for the answer. Sonnet 5.5 uses between-tools thinking, which does not spend that cap before a normal chat reply.
+* **Anthropic output limit**: Opus 5.5 and Fable keep thinking on, and those thinking tokens count against the max tokens setting. A setting below 4,000 is sent as 4,000 for those models. If the model still uses the whole cap before it writes a reply, the chatbot names the model and asks you to increase the Anthropic max tokens setting.
+
 
 * Information about past updates can be found [here](updates/updates.md).

chatbot-chatgpt/trunk/documentation/specs/functional-details.md

@@ -5 +5 @@
 The **Kognetiks Chatbot** is a comprehensive WordPress plugin that integrates advanced AI capabilities into WordPress websites. It provides intelligent conversational experiences through multiple AI platforms, offering both cloud-based and local AI solutions for enhanced visitor engagement, customer support, and interactive assistance.
 
-**Version:** 2.5.4
+**Version:** 2.5.5
 **License:** GPLv3 or later  
 **WordPress Compatibility:** Tested up to WordPress 7.1
@@ -566 +566 @@
 ## Version History
 
+## What's new in Version 2.5.5 - Released 2026-11-01
+
+### Bug Fixes
+* **Anthropic replies**: Current Claude models can return a thinking block before the answer. The plugin read only the first block, so a successful reply was replaced with a generic API error. Replies are now taken from the text blocks. Haiku 5.5, Sonnet 5, and Opus 5 turn thinking off so the token cap is available for the answer. Sonnet 5.5 uses between-tools thinking, which does not spend that cap before a normal chat reply.
+* **Anthropic output limit**: Opus 5.5 and Fable keep thinking on, and those thinking tokens count against the max tokens setting. A setting below 4,000 is sent as 4,000 for those models. If the model still uses the whole cap before it writes a reply, the chatbot names the model and asks you to increase the Anthropic max tokens setting.
+
+## What's new in Version 2.5.4 - Released 2026-10-31
+
+### Bug Fixes
+* **Anthropic model list**: The Anthropic model list had become stale. It is now refreshed from the API.
+
 ## What's new in Version 2.5.3 - Released 2026-10-29
 
 ### Bug Fixes
 * **Transcript download**: Download Transcript now saves a text file in the browser from the conversation shown in that chatbot.
-
-## What's new in Version 2.5.4 - Released TBD
-
-### Bug Fixes
-* **TBD**: TBD
 
 ## What's new in Version 2.5.2 - Released 2026-10-28

chatbot-chatgpt/trunk/documentation/updates/updates.md

@@ -1 +1 @@
 # Past Updates
 
-## What's new in Version 2.5.4 - Released TBD
-
-### Bug Fixes
-* **TBD**: TBD
+## What's new in Version 2.5.5 - Released 2026-11-01
+
+### Bug Fixes
+* **Anthropic replies**: Current Claude models can return a thinking block before the answer. The plugin read only the first block, so a successful reply was replaced with a generic API error. Replies are now taken from the text blocks. Haiku 5.5, Sonnet 5, and Opus 5 turn thinking off so the token cap is available for the answer. Sonnet 5.5 uses between-tools thinking, which does not spend that cap before a normal chat reply.
+* **Anthropic output limit**: Opus 5.5 and Fable keep thinking on, and those thinking tokens count against the max tokens setting. A setting below 4,000 is sent as 4,000 for those models. If the model still uses the whole cap before it writes a reply, the chatbot names the model and asks you to increase the Anthropic max tokens setting.
+
+
+## What's new in Version 2.5.4 - Released 2026-10-31
+
+### Bug Fixes
+* **Anthropic model list**: The Anthropic model list had become stale. It is now refreshed from the API.
 
 ## What's new in Version 2.5.3 - Released 2026-10-29

chatbot-chatgpt/trunk/includes/chatbot-call-anthropic-api.php

@@ -74 +74 @@
     $kchat_settings['model'] = $model;
  
-    // Max tokens
-    $max_tokens = intval(esc_attr(get_option('chatbot_anthropic_max_tokens_setting', '1000')));
+    // Max tokens. Models that keep thinking on need room for thinking and the reply.
+    $max_tokens = chatbot_anthropic_output_token_cap(
+        $model,
+        intval(esc_attr(get_option('chatbot_anthropic_max_tokens_setting', '1000')))
+    );
 
     // Build conversation context using standardized function - Ver 2.3.9+
@@ -195 +198 @@
 
     // Define the request body - Ver 2.3.9+
-    // Use Anthropic's native 'system' parameter and structured 'messages' array
-    $body = json_encode(array(
+    // Use Anthropic's native 'system' parameter and structured 'messages' array.
+    // max_tokens covers thinking and text, so up-front thinking is turned off for models that support it.
+    $body = array(
         'model' => $model,
         'max_tokens' => $max_tokens,
         'system' => $system_message, // Top-level parameter for system message
         'messages' => $messages,
-    ));
+    );
+    $thinking = chatbot_anthropic_thinking_config($model);
+    if (is_array($thinking)) {
+        $body['thinking'] = $thinking;
+    }
+    $body = json_encode($body);
 
     $timeout = esc_attr(get_option('chatbot_anthropic_timeout_setting', 240 ));
@@ -267 +276 @@
     }
 
-    if (isset($response_body['content'][0]['text']) && !empty($response_body['content'][0]['text'])) {
+    // Current models can return thinking blocks before the reply. Read text blocks by type.
+    // A reply that reaches max_tokens is still the reply, so that text is returned.
+    $reply = chatbot_anthropic_response_text($response_body);
+    if ('' !== $reply) {
         // Handle the response from the chat engine
         // Context History - Ver 1.6.1
-        addEntry('chatbot_chatgpt_context_history', $response_body['content'][0]['text']);
+        addEntry('chatbot_chatgpt_context_history', $reply);
         // Clear locks on success
         // Lock clearing removed - main send function handles locking
-        return $response_body['content'][0]['text'];
+        return $reply;
     } else {
+        $stop_reason = (is_array($response_body) && isset($response_body['stop_reason']) && is_string($response_body['stop_reason'])) ? sanitize_text_field($response_body['stop_reason']) : '';
+        $logged_model = chatbot_anthropic_model_id_is_valid($model) ? $model : 'unknown';
+        prod_trace('ERROR', 'No valid Anthropic text block. model=' . $logged_model . ' max_tokens=' . intval($max_tokens) . ('' !== $stop_reason ? ' stop_reason=' . $stop_reason : ''));
+        $limit_message = chatbot_anthropic_empty_reply_message($model, $stop_reason);
+        if ('' !== $limit_message) {
+            return $limit_message;
+        }
         // FIXME - Decide what to return here - it's an error
         if (get_locale() !== "en_US") {

chatbot-chatgpt/trunk/includes/settings/chatbot-settings-api-test.php

@@ -297 +297 @@
             );
 
-            // Set the body
+            // Set the body. max_tokens covers thinking and text, so up-front thinking is turned off.
+            // Models that keep thinking on use at least 4000 so the test reply is not crowded out.
             $body = array(
                 'model' => $model,
-                'max_tokens' => 100,
+                'max_tokens' => chatbot_anthropic_output_token_cap($model, 100),
                 'system' => 'You are a helpful assistant.',
                 'messages' => array(
@@ -309 +310 @@
                 )
             );
+            $thinking = chatbot_anthropic_thinking_config($model);
+            if (is_array($thinking)) {
+                $body['thinking'] = $thinking;
+            }
 
             // Encode the body
@@ -344 +349 @@
                 $updated_status = 'API Error Type: ' . $error_type . ' Message: ' . $error_message;
             
-            } elseif (isset($response_data['type']) && $response_data['type'] === 'message') {
-
-                // Handle successful response
-                $content_type = $response_data['content'][0]['type'] ?? 'Unknown Content Type';
-                $content_text = $response_data['content'][0]['text'] ?? 'No content available.';
-            
-                // Handle successful response
+            } elseif (isset($response_data['type']) && $response_data['type'] === 'message' && '' !== chatbot_anthropic_response_text($response_data)) {
+
+                // Handle successful response. Text may follow a thinking block.
                 $updated_status = 'Success: Connection to the ' . $chatbot_ai_platform_choice . ' API was successful!';
 
             } else {
 
-                // Handle unexpected response structure
-                $updated_status = 'Error: Unexpected response format from the ' . $chatbot_ai_platform_choice . ' API. Please check Settings for a valid API key or your ' . $chatbot_ai_platform_choice . ' account for additional information.';
+                $stop_reason = (is_array($response_data) && isset($response_data['stop_reason']) && is_string($response_data['stop_reason'])) ? sanitize_text_field($response_data['stop_reason']) : '';
+                $limit_message = chatbot_anthropic_empty_reply_message($model, $stop_reason);
+                if ('' !== $limit_message) {
+                    $updated_status = $limit_message;
+                } else {
+                    // Handle unexpected response structure
+                    $updated_status = 'Error: Unexpected response format from the ' . $chatbot_ai_platform_choice . ' API. Please check Settings for a valid API key or your ' . $chatbot_ai_platform_choice . ' account for additional information.';
+                }
 
             }

chatbot-chatgpt/trunk/includes/utilities/chatbot-models.php

@@ -728 +728 @@
 
     return $normalized;
+
+}
+
+// Turn off up-front thinking so the token budget is available for the reply.
+// Sonnet 5.5 rejects "disabled". Haiku 5.5 rejects "between_tools". Other models keep the request unchanged.
+function chatbot_anthropic_thinking_config( $model ) {
+
+    $id = strtolower( (string) $model );
+
+    if ( false !== strpos( $id, 'sonnet-5-5' ) ) {
+        return array( 'type' => 'between_tools' );
+    }
+
+    if ( false !== strpos( $id, 'haiku-5-5' ) || false !== strpos( $id, 'sonnet-5' ) ) {
+        return array( 'type' => 'disabled' );
+    }
+
+    if ( false !== strpos( $id, 'opus-5' ) && false === strpos( $id, 'opus-5-5' ) ) {
+        return array( 'type' => 'disabled' );
+    }
+
+    return null;
+
+}
+
+// Opus 5.5 and Fable keep adaptive thinking, and those tokens count toward max_tokens.
+function chatbot_anthropic_thinking_stays_on( $model ) {
+
+    $id = strtolower( (string) $model );
+
+    return ( false !== strpos( $id, 'opus-5-5' ) || false !== strpos( $id, 'fable-5' ) );
+
+}
+
+// A cap sized for a reply alone can be spent before any text exists on models that keep thinking on.
+function chatbot_anthropic_output_token_cap( $model, $max_tokens ) {
+
+    $cap = intval( $max_tokens );
+    if ( $cap < 1 ) {
+        $cap = 1000;
+    }
+
+    if ( chatbot_anthropic_thinking_stays_on( $model ) && $cap < 4000 ) {
+        return 4000;
+    }
+
+    return $cap;
+
+}
+
+// Shown when thinking uses the whole output cap and no reply text is returned.
+function chatbot_anthropic_empty_reply_message( $model, $stop_reason ) {
+
+    $stop_reason = is_string( $stop_reason ) ? $stop_reason : '';
+    if ( 'max_tokens' !== $stop_reason ) {
+        return '';
+    }
+
+    $name = chatbot_anthropic_model_id_is_valid( $model ) ? $model : 'The selected model';
+
+    return $name . ' used its output limit before it wrote a reply. Increase the Anthropic max tokens setting.';
+
+}
+
+// Join text blocks and skip thinking blocks that precede them.
+function chatbot_anthropic_response_text( $response_body ) {
+
+    if ( ! is_array( $response_body ) || empty( $response_body['content'] ) || ! is_array( $response_body['content'] ) ) {
+        return '';
+    }
+
+    $parts = array();
+
+    foreach ( $response_body['content'] as $block ) {
+
+        if ( ! is_array( $block ) ) {
+            continue;
+        }
+
+        $type = isset( $block['type'] ) ? $block['type'] : 'text';
+        if ( 'text' !== $type || ! isset( $block['text'] ) || ! is_string( $block['text'] ) ) {
+            continue;
+        }
+
+        if ( '' === trim( $block['text'] ) ) {
+            continue;
+        }
+
+        $parts[] = $block['text'];
+
+    }
+
+    return trim( implode( "\n", $parts ) );
 
 }

chatbot-chatgpt/trunk/readme.txt

@@ -6 +6 @@
 Tested up to: 7.1.4
 Requires PHP: 8.0
-Stable tag: 2.5.4
+Stable tag: 2.5.5
 License: GPLv3 or later
 License URI: https://www.gnu.org/licenses/gpl-3.0.html
@@ -194 +194 @@
 == Changelog ==
 
-= 2.5.4 - Released TBD =
-
-### Bug Fixes
-* **TBD**: TBD
+= 2.5.5 - Released 2026-11-01 =
+
+### Bug Fixes
+* **Anthropic replies**: Current Claude models can return a thinking block before the answer. The plugin read only the first block, so a successful reply was replaced with a generic API error. Replies are now taken from the text blocks. Haiku 5.5, Sonnet 5, and Opus 5 turn thinking off so the token cap is available for the answer. Sonnet 5.5 uses between-tools thinking, which does not spend that cap before a normal chat reply.
+* **Anthropic output limit**: Opus 5.5 and Fable keep thinking on, and those thinking tokens count against the max tokens setting. A setting below 4,000 is sent as 4,000 for those models. If the model still uses the whole cap before it writes a reply, the chatbot names the model and asks you to increase the Anthropic max tokens setting.
+
+= 2.5.4 - Released 2026-10-31 =
+
+### Bug Fixes
+* **Anthropic model list**: The Anthropic model list had become stale. It is now refreshed from the API.
 
 = 2.5.3 - Released 2026-10-29 =