Skip to content

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.rs
index 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.rs
index 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);