//! Pure Responses state laws (`SMH-SPEC-PLUG0001`, `SMH-SPEC-SPEC0001`). use super::*; use proptest::prelude::*; use smith_alloc::{Counting, Scope, measure}; #[global_allocator] static ALLOCATOR: Counting = Counting; #[test] fn failed_responses_preserve_structured_error_code_without_untrusted_message() { let mut decoder = Decoder::restore(&[]).unwrap(); let error = decoder.event( r#"{"type":"response.failed","response":{"error":{"code":"subscription_sharing_usage_limit_exceeded","message":"untrusted diagnostic"}}}"#, &mut Vec::new(), ).unwrap_err(); assert!(error.contains("subscription_sharing_usage_limit_exceeded")); assert!(!error.contains("untrusted diagnostic")); } #[test] fn completed_decode_allocation_count_is_pinned() { let chunk = b"data: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"usage\":{\"input_tokens\":1,\"output_tokens\":1}}}\n\n".to_vec(); let (step, cost) = measure(Scope::KernelCall, || { ResponsesProtocol::decode_response(Vec::new(), chunk, true) }); assert!(step.is_ok()); // One native codec call, excluding caller-owned input allocation and Wasm engine setup. assert_eq!(cost.allocations, 19); } proptest! { #[test] fn codec_state_roundtrips( pending in prop::collection::vec(any::(), 0..128), indexes in any::(), completed in any::(), refusal in any::(), ) { let original = Decoder { pending, tool_indexes:indexes, completed, refusal }; let bytes = original.save(); let restored = Decoder::restore(&bytes).unwrap(); prop_assert_eq!(&original.pending, &restored.pending); prop_assert_eq!(original.tool_indexes, restored.tool_indexes); prop_assert_eq!(original.completed, restored.completed); prop_assert_eq!(original.refusal, restored.refusal); prop_assert_eq!(bytes, restored.save()); } #[test] fn decoding_is_independent_of_chunk_partition( text in ".{0,32}", cuts in prop::collection::vec(any::(), 0..16), ) { let stream = format!("data: {}\n\ndata: {}\n\n", json!({"type":"response.output_text.delta", "delta":text}), json!({"type":"response.completed", "response":{ "status":"completed", "usage":{"input_tokens":1, "output_tokens":1} }})); let bytes = stream.as_bytes(); let expected = ResponsesProtocol::decode_response(Vec::new(), bytes.to_vec(), true).unwrap(); let mut offsets: Vec<_> = cuts.iter().map(|cut| cut % (bytes.len() + 1)).collect(); offsets.sort_unstable(); offsets.push(bytes.len()); let mut state = Vec::new(); let mut events = Vec::new(); let mut start = 0; for end in offsets { let step = ResponsesProtocol::decode_response(state, bytes[start..end].to_vec(), false).unwrap(); state = step.state; events.extend(step.events); start = end; } let step = ResponsesProtocol::decode_response(state, Vec::new(), true).unwrap(); events.extend(step.events); prop_assert_eq!(format!("{events:?}"), format!("{:?}", expected.events)); prop_assert_eq!(step.state, expected.state); } } #[test] #[cfg(target_arch = "x86_64")] fn decoder_scratch_layout_is_pinned() { assert_eq!(std::mem::size_of::(), 48); } #[test] fn multiline_sse_data_preserves_json_whitespace() { let data = sse_data(b": heartbeat\r\ndata: {\r\ndata: \"type\":\"response.created\"}\r\n\r\n") .unwrap(); assert_eq!(data, "{\n\"type\":\"response.created\"}"); let mut decoder = Decoder::restore(&[]).unwrap(); decoder.event(&data, &mut Vec::new()).unwrap(); } #[test] fn invalid_state_versions_flags_and_lengths_are_rejected() { for length in 1..STATE_HEADER_BYTES { assert!(Decoder::restore(&vec![0; length]).is_err()); } let mut state = vec![0; STATE_HEADER_BYTES]; assert!(Decoder::restore(&state).is_err()); state[0] = 1; state[1] = 4; assert!(Decoder::restore(&state).is_err()); state[1] = 0; state.resize(STATE_HEADER_BYTES + FRAME_BYTES_MAX + 1, 0); assert!(Decoder::restore(&state).is_err()); }