Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.
Rust
fix(libsy): detect file edits wrapped in Codex scripts (#979)
ryan-lempkaf26dafe42b1e
diff --git a/crates/libsy/src/algorithms/plan_execute.rs b/crates/libsy/src/algorithms/plan_execute.rsindex 2bbbc286f..6a003966c 100644--- a/crates/libsy/src/algorithms/plan_execute.rs+++ b/crates/libsy/src/algorithms/plan_execute.rs@@ -287,6 +287,34 @@ mod tests {(selected, request)}+ #[tokio::test]+ async fn wrapped_patch_handoff() {+ for (input, expected) in [+ (+ r#"text(await tools.apply_patch("*** Begin Patch\n*** Add File: a.txt\n+hello\n*** End Patch"))"#,+ EFFICIENT,+ ),+ (+ r#"const patch = "patch contents"; text(await tools.apply_patch(patch));"#,+ EFFICIENT,+ ),+ ("const patch = 'example only'; text(patch)", CAPABLE),+ ("// await tools.apply_patch('contents')", CAPABLE),+ (+ "if (false) { await tools.apply_patch('contents'); }",+ CAPABLE,+ ),+ ] {+ let request = request(vec![tool_call("exec", json!({"input": input}))], None);+ let signals = ToolSignals::from_request(&request, None);+ let dimensions = crate::algorithms::util::stage::dimensions_from_signal(&signals);+ assert_eq!(dimensions.production_intensity > 0.0, expected == EFFICIENT);+ let (selected, _) =+ route_and_capture(algorithm(PlanExecuteConfig::default()), request).await;+ assert_eq!(selected, expected, "{input}");+ }+ }+#[tokio::test]async fn plans_then_hands_off_and_latches_execution() {const HANDOFF: &str = "Continue from the plan and repository evidence.";diff --git a/crates/libsy/src/algorithms/util/tool_signals.rs b/crates/libsy/src/algorithms/util/tool_signals.rsindex 21d2909bc..914a87aff 100644--- a/crates/libsy/src/algorithms/util/tool_signals.rs+++ b/crates/libsy/src/algorithms/util/tool_signals.rs@@ -14,8 +14,10 @@use std::collections::HashSet;use std::path::Path;+use std::sync::LazyLock;use async_trait::async_trait;+use regex::Regex;use serde::Deserialize;use serde_json::Value;use switchyard_protocol::codex_namespaces::{split_qualified_name, tool_namespaces};@@ -432,6 +434,7 @@ struct ObservedToolCall<'a> {bare_name: Option<&'a str>,command: Option<String>,is_retrieval: bool,+ code_semantic: Option<ToolSemantic>,}#[derive(Debug, Clone, Copy, PartialEq, Eq)]@@ -489,6 +492,42 @@ fn classify_tool_call(name: &str, command: Option<&str>) -> ToolSemantic {classify_tool_call_with_semantics(name, command, &ToolSemantics::default())}+/// Recognize straight-line Codex patch calls, with optional literal bindings and+/// `text(...)` wrappers. Other JavaScript stays unknown, including control flow.+fn code_mode_has_patch(mut input: &str) -> bool {+ static STATEMENT: LazyLock<Regex> = LazyLock::new(|| {+ let identifier = r"[a-zA-Z_$][a-zA-Z0-9_$]*";+ let literal = r#"(?:"(?:[^"\\\r\n]|\\[^\r\n])*"|'(?:[^'\\\r\n]|\\[^\r\n])*'|`(?:[^`\\$]|\\[^\r\n])*`)"#;+ let argument = format!(r"(?:{literal}|{identifier})");+ let patch = format!(r"await\s+tools\s*\.\s*apply_patch\s*\(\s*{argument}\s*\)");+ // The pattern uses only constant fragments.+ Regex::new(&format!(+ r"(?x)\A(?://[^\r\n]*|(?s:/\*.*?\*/)|(?:+ (?:const|let)\s+(?P<binding>{identifier})\s*=\s*{literal}|+ (?P<patch>{patch}|text\s*\(\s*{patch}\s*\))|+ text\s*\(\s*{argument}\s*\)+ )[\t\x20]*(?:;|\r?\n|\z))"+ ))+ .expect("constant code-mode statement pattern")+ });+ let mut has_patch = false;+ while !input.trim_start().is_empty() {+ input = input.trim_start();+ let Some(statement) = STATEMENT.captures(input) else {+ return false;+ };+ if statement+ .name("binding")+ .is_some_and(|binding| matches!(binding.as_str(), "tools" | "text"))+ {+ return false;+ }+ has_patch |= statement.name("patch").is_some();+ input = &input[statement[0].len()..];+ }+ has_patch+}+fn classify_tool_call_with_semantics(name: &str,command: Option<&str>,@@ -1029,7 +1068,22 @@ fn extract_tool_signals_with_window_and_semantics(.arguments.as_str().and_then(|raw| serde_json::from_str::<Value>(raw).ok());- let command_field = command_of(decoded.as_ref().unwrap_or(&call.arguments));+ let arguments = decoded.as_ref().unwrap_or(&call.arguments);+ let command_field = command_of(arguments);+ // Codex uses exec.input for JavaScript. OpenClaw's exec.command+ // remains a shell call, even when the names are identical.+ let code_semantic = (bare_name.unwrap_or(&call.name) == "exec"+ && arguments.get("command").is_none()+ && arguments.get("cmd").is_none())+ .then(|| arguments.get("input").and_then(Value::as_str))+ .flatten()+ .map(|input| {+ if code_mode_has_patch(input) {+ ToolSemantic::Mutate(MutationKind::Edit)+ } else {+ ToolSemantic::Unknown+ }+ });let command = command_field.and_then(command_text);// The joined name wins, as in `build_signal`. A joined name// configured as observe still counts when its bare name is a@@ -1045,7 +1099,8 @@ fn extract_tool_signals_with_window_and_semantics(}_ => call.name.as_str(),};- let is_retrieval = is_retrieval_tool(name, command_field);+ let is_retrieval =+ code_semantic.is_none() && is_retrieval_tool(name, command_field);if !call.id.is_empty() {// A reused ID links to its latest call.if is_retrieval {@@ -1059,6 +1114,7 @@ fn extract_tool_signals_with_window_and_semantics(bare_name,command,is_retrieval,+ code_semantic,});}ContentBlock::ToolResult(result) => {@@ -1297,12 +1353,15 @@ fn build_signal(// Every read, found or missed, is an observation. The read check parses// the command, so it beats the substring patterns. Otherwise the joined// name wins, so configs that list it keep working.- let mut cat = if tc.is_retrieval {+ let mut cat = if let Some(semantic) = tc.code_semantic {+ semantic+ } else if tc.is_retrieval {ToolSemantic::Observe} else {classify_tool_call_with_semantics(&tc.name, tc.command.as_deref(), semantics)};if matches!(cat, ToolSemantic::Unknown)+ && tc.code_semantic.is_none()&& let Some(bare_name) = tc.bare_name{cat = classify_tool_call_with_semantics(bare_name, tc.command.as_deref(), semantics);