Skip to content

Commit 2348866

Browse files
ryoppippiigorovh
andcommitted
fix(opencode): skip non-string Claude Agent session IDs without unlinking
The lenient link pass read sessionID as a String inside an object, so an object-valued ID failed the deserialize mid-object, which cannot be recovered, and the whole row lost a valid link from another part. A string-only lenient type now drains objects and arrays through IgnoredAny and reads them as absent. The lenient object, string, and array wrappers move to the shared jsonl module next to lenient_vec, since they are generic serde helpers rather than OpenCode parsing. Refs #2004 Co-authored-by: igorovh <[email protected]>
1 parent 99331a3 commit 2348866

2 files changed

Lines changed: 220 additions & 123 deletions

File tree

‎rust/adapters/common/src/jsonl.rs‎

Lines changed: 209 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,15 @@
1414
//! `serde_json::from_slice`, so unused fields are skipped instead of being
1515
//! materialized into an intermediate `Value` tree.
1616
17-
use serde::{Deserialize, Deserializer, de::DeserializeOwned};
17+
use std::{fmt, marker::PhantomData};
18+
19+
use serde::{
20+
Deserialize, Deserializer,
21+
de::{
22+
self, DeserializeOwned, IgnoredAny, MapAccess, SeqAccess, Visitor,
23+
value::MapAccessDeserializer,
24+
},
25+
};
1826

1927
use ccusage_core::fast::{LinePrefilter, byte_lines};
2028

@@ -201,13 +209,159 @@ where
201209
Ok(ccusage_core::non_empty_json_string(value.as_ref()))
202210
}
203211

212+
macro_rules! skip_scalars {
213+
($empty:expr) => {
214+
fn visit_bool<E: de::Error>(self, _: bool) -> Result<Self::Value, E> {
215+
Ok($empty)
216+
}
217+
fn visit_i64<E: de::Error>(self, _: i64) -> Result<Self::Value, E> {
218+
Ok($empty)
219+
}
220+
fn visit_u64<E: de::Error>(self, _: u64) -> Result<Self::Value, E> {
221+
Ok($empty)
222+
}
223+
fn visit_f64<E: de::Error>(self, _: f64) -> Result<Self::Value, E> {
224+
Ok($empty)
225+
}
226+
fn visit_unit<E: de::Error>(self) -> Result<Self::Value, E> {
227+
Ok($empty)
228+
}
229+
};
230+
}
231+
232+
/// A JSON object read as `T`, or `None` for any other value, which is skipped
233+
/// without being built, unlike [`lenient_object`]. A failure inside the object
234+
/// cannot be recovered, so every field of `T` must be lenient too, such as
235+
/// [`LenientObject`], [`LenientString`], or [`LenientSeq`] with
236+
/// `#[serde(default)]`.
237+
pub struct LenientObject<T>(pub Option<T>);
238+
239+
impl<T> Default for LenientObject<T> {
240+
fn default() -> Self {
241+
Self(None)
242+
}
243+
}
244+
245+
impl<'de, T: Deserialize<'de>> Deserialize<'de> for LenientObject<T> {
246+
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
247+
struct ObjectVisitor<T>(PhantomData<T>);
248+
249+
impl<'de, T: Deserialize<'de>> Visitor<'de> for ObjectVisitor<T> {
250+
type Value = LenientObject<T>;
251+
252+
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
253+
formatter.write_str("any JSON value")
254+
}
255+
256+
fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
257+
T::deserialize(MapAccessDeserializer::new(map))
258+
.map(|value| LenientObject(Some(value)))
259+
}
260+
261+
fn visit_seq<A: SeqAccess<'de>>(self, seq: A) -> Result<Self::Value, A::Error> {
262+
IgnoredAny.visit_seq(seq).map(|_| LenientObject(None))
263+
}
264+
265+
fn visit_str<E: de::Error>(self, _: &str) -> Result<Self::Value, E> {
266+
Ok(LenientObject(None))
267+
}
268+
269+
skip_scalars!(LenientObject(None));
270+
}
271+
272+
deserializer.deserialize_any(ObjectVisitor(PhantomData))
273+
}
274+
}
275+
276+
/// A JSON string, or `None` for any other value, which is skipped without
277+
/// being built. Never fails, so it is safe inside a [`LenientObject`].
278+
#[derive(Default)]
279+
pub struct LenientString(pub Option<String>);
280+
281+
impl<'de> Deserialize<'de> for LenientString {
282+
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
283+
struct StringVisitor;
284+
285+
impl<'de> Visitor<'de> for StringVisitor {
286+
type Value = LenientString;
287+
288+
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
289+
formatter.write_str("any JSON value")
290+
}
291+
292+
fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
293+
Ok(LenientString(Some(value.to_owned())))
294+
}
295+
296+
fn visit_string<E: de::Error>(self, value: String) -> Result<Self::Value, E> {
297+
Ok(LenientString(Some(value)))
298+
}
299+
300+
fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
301+
IgnoredAny.visit_map(map).map(|_| LenientString(None))
302+
}
303+
304+
fn visit_seq<A: SeqAccess<'de>>(self, seq: A) -> Result<Self::Value, A::Error> {
305+
IgnoredAny.visit_seq(seq).map(|_| LenientString(None))
306+
}
307+
308+
skip_scalars!(LenientString(None));
309+
}
310+
311+
deserializer.deserialize_any(StringVisitor)
312+
}
313+
}
314+
315+
/// A JSON array read as `T` elements, or empty for any other value, which is
316+
/// skipped without being built. Elements must be lenient for one malformed
317+
/// element not to fail the whole array.
318+
pub struct LenientSeq<T>(pub Vec<T>);
319+
320+
impl<T> Default for LenientSeq<T> {
321+
fn default() -> Self {
322+
Self(Vec::new())
323+
}
324+
}
325+
326+
impl<'de, T: Deserialize<'de>> Deserialize<'de> for LenientSeq<T> {
327+
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
328+
struct SeqVisitor<T>(PhantomData<T>);
329+
330+
impl<'de, T: Deserialize<'de>> Visitor<'de> for SeqVisitor<T> {
331+
type Value = LenientSeq<T>;
332+
333+
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
334+
formatter.write_str("any JSON value")
335+
}
336+
337+
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
338+
std::iter::from_fn(|| seq.next_element().transpose())
339+
.collect::<Result<_, _>>()
340+
.map(LenientSeq)
341+
}
342+
343+
fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
344+
IgnoredAny.visit_map(map).map(|_| LenientSeq(Vec::new()))
345+
}
346+
347+
fn visit_str<E: de::Error>(self, _: &str) -> Result<Self::Value, E> {
348+
Ok(LenientSeq(Vec::new()))
349+
}
350+
351+
skip_scalars!(LenientSeq(Vec::new()));
352+
}
353+
354+
deserializer.deserialize_any(SeqVisitor(PhantomData))
355+
}
356+
}
357+
204358
#[cfg(test)]
205359
mod tests {
206360
use serde::Deserialize;
207361

208362
use super::{
209-
lenient_array, lenient_f64, lenient_i64, lenient_object, lenient_u64, lenient_vec,
210-
non_empty_string, records,
363+
LenientObject, LenientSeq, LenientString, lenient_array, lenient_f64, lenient_i64,
364+
lenient_object, lenient_u64, lenient_vec, non_empty_string, records,
211365
};
212366
use ccusage_core::fast::LinePrefilter;
213367

@@ -255,6 +409,58 @@ mod tests {
255409
);
256410
}
257411

412+
#[test]
413+
fn lenient_wrappers_skip_values_of_another_shape() {
414+
#[derive(Deserialize)]
415+
struct Part {
416+
#[serde(default)]
417+
name: LenientString,
418+
#[serde(default)]
419+
child: LenientObject<Child>,
420+
}
421+
422+
#[derive(Deserialize)]
423+
struct Child {
424+
#[serde(default)]
425+
id: LenientString,
426+
}
427+
428+
#[derive(Deserialize)]
429+
struct Parts {
430+
#[serde(default)]
431+
parts: LenientSeq<LenientObject<Part>>,
432+
}
433+
434+
let parse = |raw: &str| {
435+
serde_json::from_str::<Parts>(raw)
436+
.unwrap()
437+
.parts
438+
.0
439+
.into_iter()
440+
.map(|part| {
441+
part.0
442+
.map(|part| (part.name.0, part.child.0.and_then(|child| child.id.0)))
443+
})
444+
.collect::<Vec<_>>()
445+
};
446+
447+
assert_eq!(
448+
parse(
449+
r#"{"parts":[{"name":"a","child":{"id":"x"}},"junk",{"name":{"o":1},"child":[1]},{"name":["n"],"child":{"id":{"o":[2]}}},7,null]}"#
450+
),
451+
[
452+
Some((Some("a".to_string()), Some("x".to_string()))),
453+
None,
454+
Some((None, None)),
455+
Some((None, None)),
456+
None,
457+
None,
458+
]
459+
);
460+
assert!(parse(r#"{"parts":{"a":[1]}}"#).is_empty());
461+
assert!(parse(r#"{"parts":"x"}"#).is_empty());
462+
}
463+
258464
#[test]
259465
fn lenient_u64_matches_value_as_u64() {
260466
let coerce = |raw: &str| {

0 commit comments

Comments
 (0)