feat: improve tool-call robustness and harness normalization

Author: rexleimo

Cargo.lock

@@ -129,6 +129,9 @@ pub async fn bootstrap_with_prompt(
         )
         .await?;
 
+    normalize_features_json(workspace_dir)?;
+    ensure_features_populated(workspace_dir)?;
+
     run_init_script(workspace_dir)?;
     commit_checkpoint_if_dirty(workspace_dir, "chore: rexos harness bootstrap")?;
     Ok(())
@@ -344,6 +347,7 @@ Your job:
 Rules:
 - Work only inside the workspace directory.
 - Prefer tools (`fs_read`, `fs_write`, `shell`) to inspect and change files.
+- Do NOT just describe tool calls; actually call tools when you need to edit files.
 - After edits, run the workspace init script (`./init.sh`, or `./init.ps1` on Windows) and ensure it succeeds.
 - Commit your changes to git with a descriptive message.
 "#
@@ -356,13 +360,101 @@ Rules:
 - Work only inside the workspace directory.
 - Make small, incremental progress (one feature at a time).
 - Prefer using tools (`fs_read`, `fs_write`, `shell`) to inspect and change files.
+- Do NOT just describe tool calls; actually call tools when you need to edit files.
 - If you change code, run the workspace init script (smoke checks) and fix any failures.
 - If both `init.sh` and `init.ps1` exist, keep them functionally equivalent.
 - Append a short summary to `rexos-progress.md`.
 - Commit meaningful progress to git with a descriptive message.
 "#
 }
 
+fn ensure_features_populated(workspace_dir: &Path) -> anyhow::Result<()> {
+    let path = workspace_dir.join(FEATURES_JSON);
+    let raw = std::fs::read_to_string(&path).with_context(|| format!("read {}", path.display()))?;
+    let v: serde_json::Value =
+        serde_json::from_str(&raw).with_context(|| format!("parse {}", path.display()))?;
+    let n = v
+        .get("features")
+        .and_then(|v| v.as_array())
+        .map(|a| a.len())
+        .unwrap_or(0);
+    if n == 0 {
+        bail!(
+            "initializer did not populate features.json (features=[]). Ensure your model supports tool calling and actually uses fs_write/shell to update the workspace."
+        );
+    }
+    Ok(())
+}
+
+fn normalize_features_json(workspace_dir: &Path) -> anyhow::Result<()> {
+    let path = workspace_dir.join(FEATURES_JSON);
+    let raw = std::fs::read_to_string(&path).with_context(|| format!("read {}", path.display()))?;
+    let mut v: serde_json::Value =
+        serde_json::from_str(&raw).with_context(|| format!("parse {}", path.display()))?;
+
+    let mut changed = false;
+
+    if v.get("version").and_then(|x| x.as_i64()).is_none() {
+        v["version"] = serde_json::Value::Number(1.into());
+        changed = true;
+    }
+
+    if v.get("updated_at").and_then(|x| x.as_str()).is_none() {
+        v["updated_at"] = serde_json::Value::String(String::new());
+        changed = true;
+    }
+
+    let default_editing = "Only change `passes` (false -> true) and optionally `notes`. Do not delete or reorder items.";
+    let default_completion = "A feature can only be marked passing after required tests/smoke checks are run.";
+
+    if v.get("rules").and_then(|x| x.as_object()).is_none() {
+        v["rules"] = serde_json::json!({
+            "editing": default_editing,
+            "completion": default_completion
+        });
+        changed = true;
+    } else if let Some(obj) = v.get_mut("rules").and_then(|x| x.as_object_mut()) {
+        if obj.get("editing").and_then(|x| x.as_str()).is_none() {
+            obj.insert(
+                "editing".to_string(),
+                serde_json::Value::String(default_editing.to_string()),
+            );
+            changed = true;
+        }
+        if obj.get("completion").and_then(|x| x.as_str()).is_none() {
+            obj.insert(
+                "completion".to_string(),
+                serde_json::Value::String(default_completion.to_string()),
+            );
+            changed = true;
+        }
+    }
+
+    if v.get("features").and_then(|x| x.as_array()).is_none() {
+        v["features"] = serde_json::Value::Array(Vec::new());
+        changed = true;
+    }
+
+    if let Some(arr) = v.get_mut("features").and_then(|x| x.as_array_mut()) {
+        for f in arr {
+            let Some(obj) = f.as_object_mut() else {
+                continue;
+            };
+            if obj.get("passes").and_then(|x| x.as_bool()).is_none() {
+                obj.insert("passes".to_string(), serde_json::Value::Bool(false));
+                changed = true;
+            }
+        }
+    }
+
+    if changed {
+        let s = serde_json::to_string_pretty(&v).context("serialize features.json")?;
+        std::fs::write(&path, s).with_context(|| format!("write {}", path.display()))?;
+    }
+
+    Ok(())
+}
+
 #[derive(Debug, Clone, Copy)]
 enum InitScript {
     Bash,

crates/rexos-harness/src/lib.rs

@@ -121,8 +121,9 @@ pub struct OpenAiCompatibleClient {
 impl OpenAiCompatibleClient {
     pub fn new(base_url: String, api_key: Option<String>) -> anyhow::Result<Self> {
         let base_url = base_url.trim_end_matches('/').to_string();
+        let timeout = openai_compat_timeout();
         let http = reqwest::Client::builder()
-            .timeout(Duration::from_secs(60))
+            .timeout(timeout)
             .build()
             .context("build http client")?;
 
@@ -181,3 +182,14 @@ impl OpenAiCompatibleClient {
         })
     }
 }
+
+fn openai_compat_timeout() -> Duration {
+    const DEFAULT_SECS: u64 = 600;
+    match std::env::var("REXOS_OPENAI_COMPAT_TIMEOUT_SECS") {
+        Ok(raw) => match raw.trim().parse::<u64>() {
+            Ok(secs) if secs > 0 => Duration::from_secs(secs),
+            _ => Duration::from_secs(DEFAULT_SECS),
+        },
+        Err(_) => Duration::from_secs(DEFAULT_SECS),
+    }
+}

crates/rexos-llm/src/openai_compat.rs

@@ -7,6 +7,8 @@ rust-version.workspace = true
 
 [dependencies]
 anyhow.workspace = true
+serde.workspace = true
+serde_json.workspace = true
 rexos-kernel = { path = "../rexos-kernel" }
 rexos-llm = { path = "../rexos-llm" }
 rexos-memory = { path = "../rexos-memory" }

crates/rexos-runtime/Cargo.toml

@@ -5,7 +5,7 @@ use anyhow::{bail, Context};
 
 use rexos_kernel::router::{ModelRouter, TaskKind};
 use rexos_llm::driver::LlmDriver;
-use rexos_llm::openai_compat::{ChatCompletionRequest, ChatMessage, Role};
+use rexos_llm::openai_compat::{ChatCompletionRequest, ChatMessage, Role, ToolCall, ToolFunction};
 use rexos_llm::registry::LlmRegistry;
 use rexos_memory::MemoryStore;
 use rexos_tools::Toolset;
@@ -76,7 +76,7 @@ impl AgentRuntime {
                 model: model.clone(),
                 messages: messages.clone(),
                 tools: tool_defs.clone(),
-                temperature: None,
+                temperature: Some(0.0),
             };
 
             let assistant = self
@@ -89,9 +89,14 @@ impl AgentRuntime {
 
             let tool_calls = match assistant.tool_calls.clone() {
                 Some(calls) if !calls.is_empty() => calls,
-                _ => {
-                    return Ok(assistant.content.unwrap_or_default());
-                }
+                _ => match assistant
+                    .content
+                    .as_deref()
+                    .and_then(parse_tool_calls_from_json_content)
+                {
+                    Some(calls) => calls,
+                    None => return Ok(assistant.content.unwrap_or_default()),
+                },
             };
 
             for call in tool_calls {
@@ -102,8 +107,9 @@ impl AgentRuntime {
                     bail!("tool loop detected: {sig}");
                 }
 
+                let args_json = normalize_tool_arguments(&call.function.name, &call.function.arguments);
                 let output = tools
-                    .call(&call.function.name, &call.function.arguments)
+                    .call(&call.function.name, &args_json)
                     .await
                     .with_context(|| format!("tool {}", call.function.name))?;
 
@@ -143,3 +149,161 @@ impl AgentRuntime {
         driver.chat(req).await
     }
 }
+
+#[derive(Debug, serde::Deserialize)]
+struct JsonToolCall {
+    name: String,
+    #[serde(alias = "args")]
+    #[serde(default)]
+    arguments: Option<serde_json::Value>,
+    #[serde(flatten)]
+    extra: serde_json::Map<String, serde_json::Value>,
+}
+
+fn normalize_tool_arguments(tool_name: &str, raw_arguments_json: &str) -> String {
+    let Ok(v) = serde_json::from_str::<serde_json::Value>(raw_arguments_json) else {
+        return raw_arguments_json.to_string();
+    };
+
+    let Some(obj) = v.as_object() else {
+        return raw_arguments_json.to_string();
+    };
+
+    let matches_name = obj
+        .get("function")
+        .and_then(|v| v.as_str())
+        .or_else(|| obj.get("name").and_then(|v| v.as_str()))
+        .map(|name| name == tool_name)
+        .unwrap_or(true);
+    if !matches_name {
+        return raw_arguments_json.to_string();
+    }
+
+    let Some(inner) = obj.get("arguments") else {
+        return raw_arguments_json.to_string();
+    };
+
+    if let Some(s) = inner.as_str() {
+        return s.to_string();
+    }
+
+    serde_json::to_string(inner).unwrap_or_else(|_| raw_arguments_json.to_string())
+}
+
+fn parse_tool_calls_from_json_content(content: &str) -> Option<Vec<ToolCall>> {
+    let trimmed = content.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+
+    if let Ok(value) = serde_json::from_str::<serde_json::Value>(trimmed) {
+        if let Some(calls) = parse_json_tool_calls_from_value(value) {
+            return Some(into_tool_calls(calls));
+        }
+    }
+
+    let calls = extract_json_tool_calls_from_text(trimmed);
+    if calls.is_empty() {
+        return None;
+    }
+    Some(into_tool_calls(calls))
+}
+
+fn into_tool_calls(calls: Vec<JsonToolCall>) -> Vec<ToolCall> {
+    let mut out = Vec::new();
+    for (idx, call) in calls.into_iter().enumerate() {
+        let args_value = call
+            .arguments
+            .unwrap_or_else(|| serde_json::Value::Object(call.extra));
+        let args = if let Some(s) = args_value.as_str() {
+            s.to_string()
+        } else {
+            serde_json::to_string(&args_value).unwrap_or_else(|_| "{}".to_string())
+        };
+        out.push(ToolCall {
+            id: format!("call_json_{}", idx + 1),
+            kind: "function".to_string(),
+            function: ToolFunction {
+                name: call.name,
+                arguments: args,
+            },
+        });
+    }
+    out
+}
+
+fn parse_json_tool_calls_from_value(value: serde_json::Value) -> Option<Vec<JsonToolCall>> {
+    if let Some(arr) = value.as_array() {
+        let mut calls = Vec::new();
+        for item in arr {
+            calls.push(serde_json::from_value::<JsonToolCall>(item.clone()).ok()?);
+        }
+        return Some(calls);
+    }
+
+    serde_json::from_value::<JsonToolCall>(value).ok().map(|c| vec![c])
+}
+
+fn extract_json_tool_calls_from_text(content: &str) -> Vec<JsonToolCall> {
+    let mut calls = Vec::new();
+    for (start, _) in content.match_indices('{') {
+        if calls.len() >= 16 {
+            break;
+        }
+        let Some(end) = find_balanced_json_object_end(content, start) else {
+            continue;
+        };
+        let slice = &content[start..end];
+        let Ok(value) = serde_json::from_str::<serde_json::Value>(slice) else {
+            continue;
+        };
+        let Some(mut parsed) = parse_json_tool_calls_from_value(value) else {
+            continue;
+        };
+        calls.append(&mut parsed);
+    }
+    calls
+}
+
+fn find_balanced_json_object_end(s: &str, start: usize) -> Option<usize> {
+    let bytes = s.as_bytes();
+    if start >= bytes.len() || bytes[start] != b'{' {
+        return None;
+    }
+
+    let mut depth: i32 = 0;
+    let mut in_string = false;
+    let mut escape = false;
+
+    for (i, &b) in bytes.iter().enumerate().skip(start) {
+        if in_string {
+            if escape {
+                escape = false;
+                continue;
+            }
+            if b == b'\\' {
+                escape = true;
+                continue;
+            }
+            if b == b'"' {
+                in_string = false;
+                continue;
+            }
+            continue;
+        }
+
+        match b {
+            b'"' => in_string = true,
+            b'{' => depth += 1,
+            b'}' => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some(i + 1);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    None
+}