Merge branch 'pr-1009'

Author: lbjlaq

src-tauri/src/proxy/mappers/claude/request.rs

@@ -936,6 +936,17 @@ fn build_contents(
                         // [FIX #752] Strict signature validation
                         // Only use signatures that are cached and compatible with the target model
                         if let Some(sig) = signature {
+                            // Check signature length first - if it's too short, it's definitely invalid
+                            if sig.len() < MIN_SIGNATURE_LENGTH {
+                                tracing::warn!(
+                                    "[Thinking-Signature] Signature too short (len: {} < {}), downgrading to text.",
+                                    sig.len(), MIN_SIGNATURE_LENGTH
+                                );
+                                parts.push(json!({"text": thinking}));
+                                saw_non_thinking = true;
+                                continue;
+                            }
+                            
                             let cached_family = crate::proxy::SignatureCache::global().get_signature_family(sig);
 
                             match cached_family {
@@ -966,14 +977,31 @@ fn build_contents(
                                     parts.push(part);
                                 }
                                 None => {
-                                    // Unknown signature origin: downgrade to text for safety
-                                    tracing::warn!(
-                                        "[Thinking-Signature] Unknown signature origin (len: {}). Downgrading to text for safety.",
-                                        sig.len()
-                                    );
-                                    parts.push(json!({"text": thinking}));
-                                    saw_non_thinking = true;
-                                    continue;
+                                    // For JSON tool calling compatibility, if signature is long enough but unknown,
+                                    // we should trust it rather than downgrade to text
+                                    if sig.len() >= MIN_SIGNATURE_LENGTH {
+                                        tracing::debug!(
+                                            "[Thinking-Signature] Unknown signature origin but valid length (len: {}), using as-is for JSON tool calling.",
+                                            sig.len()
+                                        );
+                                        *last_thought_signature = Some(sig.clone());
+                                        let mut part = json!({
+                                            "text": thinking,
+                                            "thought": true,
+                                            "thoughtSignature": sig
+                                        });
+                                        crate::proxy::common::json_schema::clean_json_schema(&mut part);
+                                        parts.push(part);
+                                    } else {
+                                        // Unknown and too short: downgrade to text for safety
+                                        tracing::warn!(
+                                            "[Thinking-Signature] Unknown signature origin and too short (len: {}). Downgrading to text for safety.",
+                                            sig.len()
+                                        );
+                                        parts.push(json!({"text": thinking}));
+                                        saw_non_thinking = true;
+                                        continue;
+                                    }
                                 }
                             }
                         } else {
@@ -1088,8 +1116,13 @@ fn build_contents(
                             if is_retry && signature.is_none() {
                                 tracing::warn!("[Tool-Signature] Skipping signature backfill for tool_use: {} during retry.", id);
                             } else {
-                                // Check signature length
-                                if sig.len() >= MIN_SIGNATURE_LENGTH {
+                                // Check signature length first - if it's too short, it's definitely invalid
+                                if sig.len() < MIN_SIGNATURE_LENGTH {
+                                    tracing::warn!(
+                                        "[Tool-Signature] Signature too short for tool_use: {} (len: {} < {}), skipping.",
+                                        id, sig.len(), MIN_SIGNATURE_LENGTH
+                                    );
+                                } else {
                                     // Check signature compatibility (optional for tool_use)
                                     let cached_family = crate::proxy::SignatureCache::global()
                                         .get_signature_family(&sig);
@@ -1108,27 +1141,32 @@ fn build_contents(
                                             }
                                         }
                                         None => {
-                                            // Unknown origin: only use in non-thinking mode
-                                            if is_thinking_enabled {
-                                                tracing::warn!(
-                                                    "[Tool-Signature] Unknown signature origin for tool_use: {} (len: {}). Dropping in thinking mode.",
-                                                    id, sig.len()
+                                            // For JSON tool calling compatibility, if signature is long enough but unknown,
+                                            // we should trust it rather than drop it
+                                            if sig.len() >= MIN_SIGNATURE_LENGTH {
+                                                tracing::debug!(
+                                                    "[Tool-Signature] Unknown signature origin but valid length (len: {}) for tool_use: {}, using as-is for JSON tool calling.",
+                                                    sig.len(), id
                                                 );
-                                                false
-                                            } else {
-                                                // In non-thinking mode, allow unknown signatures
                                                 true
+                                            } else {
+                                                // Unknown and too short: only use in non-thinking mode
+                                                if is_thinking_enabled {
+                                                    tracing::warn!(
+                                                        "[Tool-Signature] Unknown signature origin and too short for tool_use: {} (len: {}). Dropping in thinking mode.",
+                                                        id, sig.len()
+                                                    );
+                                                    false
+                                                } else {
+                                                    // In non-thinking mode, allow unknown signatures
+                                                    true
+                                                }
                                             }
                                         }
                                     };
                                     if should_use_sig {
                                         part["thoughtSignature"] = json!(sig);
                                     }
-                                } else {
-                                    tracing::warn!(
-                                        "[Tool-Signature] Signature too short for tool_use: {} (len: {})",
-                                        id, sig.len()
-                                    );
                                 }
                             }
                         } else {

src-tauri/src/proxy/mappers/claude/thinking_utils.rs

@@ -188,12 +188,13 @@ pub fn filter_invalid_thinking_blocks_with_family(
             let original_len = blocks.len();
             blocks.retain(|block| {
                 if let ContentBlock::Thinking { signature, .. } = block {
-                    // 1. Basic length check
+                    // 1. Basic length check - allow empty signatures to pass through for compatibility
                     let sig = match signature {
-                        Some(s) if s.len() >= MIN_SIGNATURE_LENGTH => s,
+                        Some(s) if s.len() >= MIN_SIGNATURE_LENGTH || s.is_empty() => s,
+                        None => return true, // Allow None signatures to pass through
                         _ => {
                             stripped_count += 1;
-                            return false; 
+                            return false;
                         }
                     };