lib/llm/src/protocols/common.rs (1)

1071-1094: Add JSON at-limit acceptance cases.

JSON currently only has rejection tests. Add exact-boundary tests for serialized byte length and nesting depth to lock the intended off-by-one behavior.

🧪 Proposed boundary tests

     fn test_guided_json_byte_length_rejected() {
         // A JSON string of (LIMIT+1) `a`s serializes to LIMIT+3 bytes (two
         // surrounding quotes), which trips the byte-length cap before any
         // depth check.
         let big_string = "a".repeat(MAX_JSON_SCHEMA_BYTE_LENGTH + 1);
         let json = serde_json::Value::String(big_string);
         let result = GuidedDecodingOptions::validated(Some(json), None, None, None, None, None);
         assert!(result.is_err());
         assert!(result.unwrap_err().to_string().contains("byte length"));
     }
+
+    #[test]
+    fn test_guided_json_byte_length_at_limit_accepted() {
+        // Two bytes are used by the surrounding JSON string quotes.
+        let s = "a".repeat(MAX_JSON_SCHEMA_BYTE_LENGTH - 2);
+        let json = serde_json::Value::String(s);
+        let result = GuidedDecodingOptions::validated(Some(json), None, None, None, None, None);
+        assert!(result.is_ok());
+    }
 
     #[test]
     fn test_guided_json_nesting_depth_rejected() {
         // Build a chain of `MAX_JSON_SCHEMA_NESTING_DEPTH + 1` nested objects,
         // each `{"a": ...}`. The serialized form stays well under the byte cap.
         let mut value = serde_json::json!({});
         for _ in 0..(MAX_JSON_SCHEMA_NESTING_DEPTH + 1) {
             value = serde_json::json!({ "a": value });
         }
         let result = GuidedDecodingOptions::validated(Some(value), None, None, None, None, None);
         assert!(result.is_err());
         assert!(result.unwrap_err().to_string().contains("nesting depth"));
     }
+
+    #[test]
+    fn test_guided_json_nesting_depth_at_limit_accepted() {
+        let mut value = serde_json::json!("leaf");
+        for _ in 0..MAX_JSON_SCHEMA_NESTING_DEPTH {
+            value = serde_json::json!({ "a": value });
+        }
+        let result = GuidedDecodingOptions::validated(Some(value), None, None, None, None, None);
+        assert!(result.is_ok());
+    }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@lib/llm/src/protocols/common.rs` around lines 1071 - 1094, Add two tests that
assert acceptance at the exact boundaries: for byte length, create a string of
length MAX_JSON_SCHEMA_BYTE_LENGTH - 2 (so serialized JSON string including
quotes equals MAX_JSON_SCHEMA_BYTE_LENGTH), wrap it as
serde_json::Value::String, call GuidedDecodingOptions::validated(Some(...),
None, None, None, None, None) and assert Ok (e.g.,
test_guided_json_byte_length_accepted_at_limit); for nesting depth, build a
chain of exactly MAX_JSON_SCHEMA_NESTING_DEPTH nested objects (not +1), call
GuidedDecodingOptions::validated with that value and assert Ok (e.g.,
test_guided_json_nesting_depth_accepted_at_limit). Use the existing
MAX_JSON_SCHEMA_BYTE_LENGTH, MAX_JSON_SCHEMA_NESTING_DEPTH, and
GuidedDecodingOptions::validated identifiers to locate where to add them.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes