Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
//! Bounded JSON-with-comments edits preserve every byte outside the selected object member.
//! Native syntax policy preserves each consumer's grammar; duplicate keys always fail.
use std::ops::Range;
use serde_json::{Map, Value};
use zeroize::Zeroizing;
use super::super::{QoderNativeError, qoder_error};
pub(super) const LIMIT: usize = 1024 * 1024;
pub(super) struct Document<'a> {
bytes: &'a [u8],
pub root: Node,
trailing_commas: bool,
}
pub(super) struct Node {
pub value: Value,
pub range: Range<usize>,
members: Vec<Member>,
}
struct Member {
key: String,
start: usize,
value: Range<usize>,
comma: Option<usize>,
}
impl<'a> Document<'a> {
pub fn parse(bytes: &'a [u8]) -> Result<Self, QoderNativeError> {
Self::parse_with_trailing_commas(bytes, false)
}
pub fn parse_with_trailing_commas(
bytes: &'a [u8],
trailing_commas: bool,
) -> Result<Self, QoderNativeError> {
if bytes.len() > LIMIT || std::str::from_utf8(bytes).is_err() {
return Err(invalid());
}
let mut parser = Parser {
bytes,
pos: 0,
trailing_commas,
};
// Match Qoder's BOM handling without changing the original bytes.
if bytes.starts_with(&[0xef, 0xbb, 0xbf]) {
parser.pos = 3;
}
let root = parser.value(0)?;
parser.skip()?;
if parser.pos != bytes.len() || !root.value.is_object() {
return Err(invalid());
}
Ok(Self {
bytes,
root,
trailing_commas,
})
}
pub fn object(&self, parent: &Node, key: &str) -> Result<Option<Node>, QoderNativeError> {
let Some(member) = parent.members.iter().find(|member| member.key == key) else {
return Ok(None);
};
let mut parser = Parser {
bytes: self.bytes,
pos: member.value.start,
trailing_commas: self.trailing_commas,
};
let node = parser.value(0)?;
if !node.value.is_object() {
return Err(invalid());
}
Ok(Some(node))
}
pub fn edit(
&self,
object: &Node,
key: &str,
value: Option<&Value>,
) -> Result<Zeroizing<Vec<u8>>, QoderNativeError> {
let mut edits: Vec<(Range<usize>, Vec<u8>)> = Vec::new();
if let Some((index, member)) = object
.members
.iter()
.enumerate()
.find(|(_, member)| member.key == key)
{
if let Some(value) = value {
edits.push((
member.value.clone(),
serde_json::to_vec(value).map_err(|_| invalid())?,
));
} else {
edits.push((member.start..member.value.end, Vec::new()));
if let Some(comma) = member
.comma
.or_else(|| index.checked_sub(1).and_then(|i| object.members[i].comma))
{
edits.push((comma..comma + 1, Vec::new()));
}
}
} else if let Some(value) = value {
let trailing = object
.members
.last()
.is_some_and(|member| member.comma.is_some());
let mut insert = if object.members.is_empty() || trailing {
Vec::new()
} else {
b",".to_vec()
};
insert.push(b'\n');
insert.extend(serde_json::to_vec(key).map_err(|_| invalid())?);
insert.push(b':');
insert.extend(serde_json::to_vec(value).map_err(|_| invalid())?);
if trailing {
insert.push(b',');
}
insert.push(b'\n');
edits.push((object.range.end - 1..object.range.end - 1, insert));
}
edits.sort_by_key(|(range, _)| std::cmp::Reverse(range.start));
let mut result = Zeroizing::new(self.bytes.to_vec());
for (range, replacement) in edits {
result.splice(range, replacement);
}
Document::parse_with_trailing_commas(&result, self.trailing_commas)?;
Ok(result)
}
}
struct Parser<'a> {
bytes: &'a [u8],
pos: usize,
trailing_commas: bool,
}
impl Parser<'_> {
fn skip(&mut self) -> Result<(), QoderNativeError> {
loop {
while self
.bytes
.get(self.pos)
.is_some_and(|byte| matches!(byte, b' ' | b'\t' | b'\r' | b'\n'))
{
self.pos += 1;
}
match self.bytes.get(self.pos..self.pos.saturating_add(2)) {
Some(b"//") => {
self.pos += 2;
while self.bytes.get(self.pos).is_some_and(|byte| *byte != b'\n') {
// Qoder 1.1.65's settings readers disagree on these line endings:
// strip-comments accepts LF/CRLF, while persistence tokenization also
// ends comments on standalone CR and Unicode line separators. Never
// accept a document whose foreign fields one reader could hide.
if (self.bytes[self.pos] == b'\r'
&& self.bytes.get(self.pos + 1) != Some(&b'\n'))
|| self.bytes[self.pos..].starts_with(&[0xe2, 0x80, 0xa8])
|| self.bytes[self.pos..].starts_with(&[0xe2, 0x80, 0xa9])
{
return Err(invalid());
}
self.pos += 1;
}
}
Some(b"/*") => {
self.pos += 2;
loop {
if self.bytes.get(self.pos..self.pos.saturating_add(2)) == Some(b"*/") {
self.pos += 2;
break;
}
if self.pos >= self.bytes.len() {
return Err(invalid());
}
self.pos += 1;
}
}
_ => return Ok(()),
}
}
}
fn string(&mut self) -> Result<String, QoderNativeError> {
let start = self.pos;
if self.bytes.get(self.pos) != Some(&b'"') {
return Err(invalid());
}
self.pos += 1;
loop {
match self.bytes.get(self.pos) {
Some(b'"') => {
self.pos += 1;
break;
}
Some(b'\\') => {
self.pos += 2;
}
Some(_) => self.pos += 1,
None => return Err(invalid()),
}
}
serde_json::from_slice(&self.bytes[start..self.pos]).map_err(|_| invalid())
}
fn value(&mut self, depth: usize) -> Result<Node, QoderNativeError> {
if depth > 64 {
return Err(invalid());
}
self.skip()?;
let start = self.pos;
let mut members = Vec::new();
let value = match self.bytes.get(self.pos) {
Some(b'{') => {
self.pos += 1;
self.skip()?;
let mut object = Map::new();
if self.bytes.get(self.pos) != Some(&b'}') {
loop {
self.skip()?;
let key_start = self.pos;
let key = self.string()?;
self.skip()?;
if self.bytes.get(self.pos) != Some(&b':') {
return Err(invalid());
}
self.pos += 1;
let child = self.value(depth + 1)?;
if object.insert(key.clone(), child.value).is_some() {
return Err(invalid());
}
self.skip()?;
let comma = (self.bytes.get(self.pos) == Some(&b',')).then_some(self.pos);
members.push(Member {
key,
start: key_start,
value: child.range,
comma,
});
if comma.is_none() {
break;
}
self.pos += 1;
self.skip()?;
if self.trailing_commas && self.bytes.get(self.pos) == Some(&b'}') {
break;
}
}
}
if self.bytes.get(self.pos) != Some(&b'}') {
return Err(invalid());
}
self.pos += 1;
Value::Object(object)
}
Some(b'[') => {
self.pos += 1;
self.skip()?;
let mut array = Vec::new();
if self.bytes.get(self.pos) != Some(&b']') {
loop {
array.push(self.value(depth + 1)?.value);
self.skip()?;
if self.bytes.get(self.pos) != Some(&b',') {
break;
}
self.pos += 1;
self.skip()?;
if self.trailing_commas && self.bytes.get(self.pos) == Some(&b']') {
break;
}
}
}
if self.bytes.get(self.pos) != Some(&b']') {
return Err(invalid());
}
self.pos += 1;
Value::Array(array)
}
Some(b'"') => Value::String(self.string()?),
Some(_) => {
while self.bytes.get(self.pos).is_some_and(|byte| {
!matches!(
byte,
b' ' | b'\t' | b'\r' | b'\n' | b',' | b'}' | b']' | b'/'
)
}) {
self.pos += 1;
}
if self.pos == start {
return Err(invalid());
}
serde_json::from_slice(&self.bytes[start..self.pos]).map_err(|_| invalid())?
}
None => return Err(invalid()),
};
Ok(Node {
value,
range: start..self.pos,
members,
})
}
}
fn invalid() -> QoderNativeError {
qoder_error("native settings JSON")
}
#[cfg(test)]
mod syntax_tests {
use super::*;
#[test]
fn opencode_trailing_separators_survive_owned_edits() {
let input = b"{ // unrelated\n\"list\":[1,2,],\n\"provider\":{\"user\":{\"key\":true,},}, // preserve\n}";
assert!(Document::parse(input).is_err());
let document = Document::parse_with_trailing_commas(input, true).unwrap();
let providers = document
.object(&document.root, "provider")
.unwrap()
.unwrap();
let added = document
.edit(
&providers,
"managed",
Some(&serde_json::json!({"id":"route"})),
)
.unwrap();
assert!(String::from_utf8_lossy(&added).contains("// preserve"));
assert!(String::from_utf8_lossy(&added).contains("\"list\":[1,2,]"));
let document = Document::parse_with_trailing_commas(&added, true).unwrap();
let providers = document
.object(&document.root, "provider")
.unwrap()
.unwrap();
let removed = document.edit(&providers, "managed", None).unwrap();
let parsed = Document::parse_with_trailing_commas(&removed, true).unwrap();
assert_eq!(
parsed.root.value["provider"],
serde_json::json!({"user":{"key":true}})
);
assert!(String::from_utf8_lossy(&removed).contains("\"user\":{\"key\":true,}"));
}
#[test]
fn opencode_policy_never_admits_duplicate_or_empty_members() {
for input in [b"{\"a\":1,\"a\":2,}".as_slice(), b"{\"a\":[1,,]}", b"{,}"] {
assert!(Document::parse_with_trailing_commas(input, true).is_err());
}
}
}