npm - buildwithnexus - Versions diffs - 0.11.2 → 0.11.4 - Mend

buildwithnexus 0.11.2 → 0.11.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/harness/Cargo.lock +1 -1
package/harness/Cargo.toml +1 -1
package/harness/src/agent.rs +373 -20
package/harness/src/provider.rs +193 -14
package/harness/src/tools.rs +113 -8
package/package.json +1 -1

package/harness/Cargo.lock CHANGED Viewed

@@ -49,7 +49,7 @@ checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
 [[package]]
 name = "buildwithnexus"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "criterion",
  "crossterm",

package/harness/Cargo.toml CHANGED Viewed

@@ -1,6 +1,6 @@
 [package]
 name = "buildwithnexus"
-version = "0.11.2"
+version = "0.11.4"
 edition = "2021"
 description = "A hilariously fast agentic AI CLI harness — remote or local models, full TUI with modes, memory, skills, hooks, and image input"
 license = "MIT"

package/harness/src/agent.rs CHANGED Viewed

@@ -711,12 +711,288 @@ fn is_casual_turn(text: &str) -> bool {
 }
 fn parse_text_tool_calls(text: &str, defs: &[tools::ToolDef]) -> Option<Vec<provider::ToolCall>> {
-    let candidate = extract_json_tool_candidate(text)?;
-    let value = serde_json::from_str::<serde_json::Value>(candidate).ok()?;
     let names = defs.iter().map(|d| d.name).collect::<HashSet<_>>();
-    let mut calls = Vec::new();
-    collect_text_tool_calls(&value, &names, &mut calls);
-    (!calls.is_empty()).then_some(calls)
+    if let Some(candidate) = extract_json_tool_candidate(text) {
+        if let Ok(value) = serde_json::from_str::<serde_json::Value>(candidate) {
+            let mut calls = Vec::new();
+            collect_text_tool_calls(&value, &names, &mut calls);
+            if !calls.is_empty() {
+                return Some(calls);
+            }
+        }
+    }
+    // Fall back to Gemma's `tool_code` Python-call format.
+    parse_tool_code_call(text, &names)
+}
+// Positional argument names for the tools small models most often call, so a
+// Gemma call like `write_file("/p", """…""")` maps arg 0→path, arg 1→content.
+fn positional_params(name: &str) -> &'static [&'static str] {
+    match name {
+        "write_file" | "write" => &["path", "content"],
+        "read_file" | "read" => &["path"],
+        "edit_file" | "edit" => &["path", "old", "new"],
+        "run_command" | "bash" => &["command"],
+        "Artifact" | "publish_artifact" => &["contents"],
+        "list_dir" | "list" => &["path"],
+        "find_files" | "glob" => &["pattern"],
+        "grep_files" | "grep" => &["pattern"],
+        "finish" => &["summary"],
+        "python_tool" => &["code"],
+        "create_docx" => &["path", "title", "body"],
+        _ => &[],
+    }
+}
+// Gemma emits tool calls as a ```tool_code fenced Python function call, e.g.
+//   write_file("/p/index.html", """<!doctype html>…""")
+//   Artifact(contents="""…""")
+// sometimes wrapped in `print(...)`. Native tool_calls / JSON never match, so
+// the call is otherwise treated as prose. Parse the first known-tool call.
+fn parse_tool_code_call(
+    text: &str,
+    allowed: &HashSet<&'static str>,
+) -> Option<Vec<provider::ToolCall>> {
+    let scope = tool_code_scope(text);
+    let (name, after) = find_tool_call(scope, allowed)?;
+    let inside = balanced_parens(after)?;
+    let args = parse_python_args(inside);
+    let input = tool_code_args_to_input(name, args);
+    Some(vec![text_tool_call(name, input)])
+}
+// The region to scan: inside a ```tool_code fence when present, else the whole
+// text (Gemma sometimes omits the fence).
+fn tool_code_scope(text: &str) -> &str {
+    if let Some(pos) = text.find("```tool_code") {
+        let after = &text[pos + "```tool_code".len()..];
+        let end = after.find("```").unwrap_or(after.len());
+        &after[..end]
+    } else {
+        text
+    }
+}
+// Find the earliest occurrence of a known tool name immediately followed by
+// `(` (skipping any `print(` wrapper, which isn't a known tool). Returns the
+// name and the slice just after the opening paren.
+fn find_tool_call<'a>(
+    scope: &'a str,
+    allowed: &HashSet<&'static str>,
+) -> Option<(&'static str, &'a str)> {
+    let bytes = scope.as_bytes();
+    let mut best: Option<(usize, &'static str, usize)> = None;
+    for &name in allowed.iter() {
+        let mut from = 0;
+        while let Some(rel) = scope[from..].find(name) {
+            let at = from + rel;
+            // Must be a whole identifier (not a substring of a longer name).
+            let before_ok = at == 0 || !is_ident_byte(bytes[at - 1]);
+            let after_idx = at + name.len();
+            let mut j = after_idx;
+            while j < bytes.len() && bytes[j] == b' ' {
+                j += 1;
+            }
+            if before_ok && j < bytes.len() && bytes[j] == b'(' {
+                if best.map(|(p, _, _)| at < p).unwrap_or(true) {
+                    best = Some((at, name, j + 1));
+                }
+                break;
+            }
+            from = at + name.len();
+        }
+    }
+    best.map(|(_, name, paren)| (name, &scope[paren..]))
+}
+fn is_ident_byte(b: u8) -> bool {
+    b.is_ascii_alphanumeric() || b == b'_'
+}
+// Given the slice just after an opening `(`, return the argument text up to the
+// matching `)`, tracking string literals (triple/single/double) and nesting.
+fn balanced_parens(s: &str) -> Option<&str> {
+    let bytes = s.as_bytes();
+    let mut depth = 1i32;
+    let mut i = 0;
+    while i < bytes.len() {
+        // Skip string literals whole so commas/parens inside don't count.
+        if let Some(consumed) = string_literal_len(&s[i..]) {
+            i += consumed;
+            continue;
+        }
+        match bytes[i] {
+            b'(' | b'[' | b'{' => depth += 1,
+            b')' | b']' | b'}' => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some(&s[..i]);
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    None
+}
+// If `s` starts with a Python string literal, return its byte length (including
+// delimiters). Handles triple `"""`/`'''` (raw) and single `"`/`'` (with `\`
+// escapes). None if `s` doesn't start with a quote.
+fn string_literal_len(s: &str) -> Option<usize> {
+    let b = s.as_bytes();
+    for q in ["\"\"\"", "'''"] {
+        if let Some(rest) = s.strip_prefix(q) {
+            let close = rest.find(q)?;
+            return Some(q.len() + close + q.len());
+        }
+    }
+    let quote = *b.first()?;
+    if quote == b'"' || quote == b'\'' {
+        let mut i = 1;
+        while i < b.len() {
+            if b[i] == b'\\' {
+                i += 2;
+                continue;
+            }
+            if b[i] == quote {
+                return Some(i + 1);
+            }
+            i += 1;
+        }
+    }
+    None
+}
+// Split a Python argument list at top-level commas, then classify each as
+// keyword (`name=value`) or positional, with the value parsed to a JSON value.
+fn parse_python_args(inside: &str) -> Vec<(Option<String>, serde_json::Value)> {
+    let bytes = inside.as_bytes();
+    let mut parts: Vec<&str> = Vec::new();
+    let (mut start, mut i) = (0usize, 0usize);
+    while i < bytes.len() {
+        if let Some(consumed) = string_literal_len(&inside[i..]) {
+            i += consumed;
+            continue;
+        }
+        match bytes[i] {
+            b'(' | b'[' | b'{' => {
+                if let Some(inner) = balanced_parens(&inside[i + 1..]) {
+                    i += 1 + inner.len();
+                }
+            }
+            b',' => {
+                parts.push(&inside[start..i]);
+                start = i + 1;
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    if start < inside.len() {
+        parts.push(&inside[start..]);
+    }
+    parts
+        .into_iter()
+        .filter_map(|p| {
+            let p = p.trim();
+            if p.is_empty() {
+                return None;
+            }
+            // Keyword only if the `=` precedes any string literal.
+            if let Some(eq) = kw_eq_pos(p) {
+                let key = p[..eq].trim();
+                if !key.is_empty() && key.chars().all(|c| c.is_alphanumeric() || c == '_') {
+                    return Some((Some(key.to_string()), parse_py_value(p[eq + 1..].trim())));
+                }
+            }
+            Some((None, parse_py_value(p)))
+        })
+        .collect()
+}
+// Position of a top-level `=` (keyword separator) before any string literal,
+// or None. `==`/`!=`/`>=`/`<=` are not keyword separators.
+fn kw_eq_pos(p: &str) -> Option<usize> {
+    let b = p.as_bytes();
+    let mut i = 0;
+    while i < b.len() {
+        if string_literal_len(&p[i..]).is_some() {
+            return None; // hit a string before any '='
+        }
+        if b[i] == b'=' {
+            let prev = if i > 0 { b[i - 1] } else { b' ' };
+            let next = b.get(i + 1).copied().unwrap_or(b' ');
+            if prev != b'!' && prev != b'<' && prev != b'>' && next != b'=' {
+                return Some(i);
+            }
+        }
+        i += 1;
+    }
+    None
+}
+// Parse a Python literal value into JSON: triple/single/double-quoted strings,
+// booleans, and numbers; anything else becomes a raw string.
+fn parse_py_value(expr: &str) -> serde_json::Value {
+    let e = expr.trim();
+    for q in ["\"\"\"", "'''"] {
+        if let Some(rest) = e.strip_prefix(q) {
+            if let Some(end) = rest.rfind(q) {
+                return serde_json::Value::String(rest[..end].to_string());
+            }
+        }
+    }
+    if (e.starts_with('"') && e.ends_with('"') && e.len() >= 2)
+        || (e.starts_with('\'') && e.ends_with('\'') && e.len() >= 2)
+    {
+        let inner = &e[1..e.len() - 1];
+        // Unescape the common sequences for single-quoted strings.
+        let unescaped = inner
+            .replace("\\n", "\n")
+            .replace("\\t", "\t")
+            .replace("\\\"", "\"")
+            .replace("\\'", "'")
+            .replace("\\\\", "\\");
+        return serde_json::Value::String(unescaped);
+    }
+    match e {
+        "True" | "true" => return serde_json::Value::Bool(true),
+        "False" | "false" => return serde_json::Value::Bool(false),
+        _ => {}
+    }
+    if let Ok(n) = e.parse::<i64>() {
+        return serde_json::Value::from(n);
+    }
+    if let Ok(f) = e.parse::<f64>() {
+        return serde_json::Value::from(f);
+    }
+    serde_json::Value::String(e.to_string())
+}
+// Build the tool input object: keyword args by name, positional args mapped
+// through the tool's positional signature.
+fn tool_code_args_to_input(
+    name: &str,
+    args: Vec<(Option<String>, serde_json::Value)>,
+) -> serde_json::Value {
+    let mut map = serde_json::Map::new();
+    let params = positional_params(name);
+    let mut pos = 0;
+    for (key, val) in args {
+        match key {
+            Some(k) => {
+                map.insert(k, val);
+            }
+            None => {
+                if let Some(pname) = params.get(pos) {
+                    map.insert((*pname).to_string(), val);
+                }
+                pos += 1;
+            }
+        }
+    }
+    serde_json::Value::Object(map)
 }
 fn extract_json_tool_candidate(text: &str) -> Option<&str> {
@@ -866,6 +1142,17 @@ fn text_tool_call(name: &str, input: serde_json::Value) -> provider::ToolCall {
     }
 }
+// The single-line composer prompt for reading a question answer. Kept on one
+// line (no `\n`) so the alt-screen composer positions the cursor correctly and
+// echoes typed input; the question text itself is printed separately above.
+fn answer_input_prompt(default: &str) -> String {
+    if default.is_empty() {
+        "  Answer: ".to_string()
+    } else {
+        format!("  Answer {}: ", tui::dim(&format!("[{default}]")))
+    }
+}
 fn answer_question(input: &serde_json::Value) -> (String, bool) {
     let question = if let Some(qs) = input["questions"].as_array() {
         let mut acc = Vec::new();
@@ -915,21 +1202,16 @@ fn answer_question(input: &serde_json::Value) -> (String, bool) {
         );
     }
     let default = input["default"].as_str().unwrap_or("").trim();
-    let prompt = if default.is_empty() {
-        format!(
-            "  {} {}\n  Answer: ",
-            tui::yellow("?"),
-            tui::bold(&full_prompt)
-        )
-    } else {
-        format!(
-            "  {} {}\n  Answer {} ",
-            tui::yellow("?"),
-            tui::bold(&full_prompt),
-            tui::dim(&format!("[{default}]"))
-        )
-    };
-    let ans = tui::ask(&prompt).unwrap_or_default();
+    // Render the question on its own transcript line, then read the answer with
+    // a SINGLE-LINE composer prompt. A multi-line prompt string mis-positions
+    // the alt-screen composer cursor (prompt_width counts across the newline),
+    // which hides what the user types.
+    tui::line(&format!(
+        "  {} {}",
+        tui::yellow("?"),
+        tui::bold(&full_prompt)
+    ));
+    let ans = tui::ask(&answer_input_prompt(default)).unwrap_or_default();
     let out = if ans.trim().is_empty() && !default.is_empty() {
         default.to_string()
     } else {
@@ -3244,6 +3526,18 @@ mod tests {
     use super::*;
     use serde_json::json;
+    #[test]
+    fn answer_input_prompt_is_single_line() {
+        // Must never contain a newline — a multi-line prompt breaks the
+        // alt-screen composer's cursor positioning and hides typed input.
+        let p = answer_input_prompt("");
+        assert!(!p.contains('\n'));
+        assert!(p.contains("Answer"));
+        let d = answer_input_prompt("yes");
+        assert!(!d.contains('\n'));
+        assert!(d.contains("yes"));
+    }
     #[test]
     fn permission_parsing() {
         assert!(matches!(permission("auto"), Permission::Auto));
@@ -3328,6 +3622,65 @@ mod tests {
         assert_eq!(b.calls[0].input["path"], "b.txt");
     }
+    #[test]
+    fn gemma_tool_code_write_file_positional_triple_quoted() {
+        // The exact shape captured from gemma-2-2b-it: a ```tool_code fence with
+        // a Python call, positional args, and triple-quoted HTML containing
+        // commas, parens, and braces.
+        let defs = tools::defs_for_context(true, 8192);
+        let text = "```tool_code\nwrite_file(\"/p/index.html\", \"\"\"<!doctype html>\\n<canvas id=\"c\"></canvas>\\n<script>const a={x:1}; f(a,b);</script>\"\"\")\n```";
+        let r = normalize_text_tool_calls(
+            Reply {
+                text: text.to_string(),
+                ..Default::default()
+            },
+            &defs,
+            "build a canvas game",
+        );
+        assert_eq!(r.calls.len(), 1, "text: {}", r.text);
+        assert_eq!(r.calls[0].name, "write_file");
+        assert_eq!(r.calls[0].input["path"], "/p/index.html");
+        let content = r.calls[0].input["content"].as_str().unwrap();
+        assert!(content.contains("<canvas"), "{content}");
+        assert!(content.contains("f(a,b)"), "{content}");
+    }
+    #[test]
+    fn gemma_tool_code_keyword_and_print_wrapper() {
+        let defs = tools::defs_for_context(true, 8192);
+        // Keyword arg + a print(...) wrapper Gemma sometimes adds.
+        let text =
+            "```tool_code\nprint(Artifact(title=\"Game\", contents=\"\"\"<html>ok</html>\"\"\"))\n```";
+        let r = normalize_text_tool_calls(
+            Reply {
+                text: text.to_string(),
+                ..Default::default()
+            },
+            &defs,
+            "build it",
+        );
+        assert_eq!(r.calls.len(), 1);
+        assert_eq!(r.calls[0].name, "Artifact");
+        assert_eq!(r.calls[0].input["title"], "Game");
+        assert_eq!(r.calls[0].input["contents"], "<html>ok</html>");
+    }
+    #[test]
+    fn python_value_and_arg_parsing_helpers() {
+        assert_eq!(parse_py_value("\"\"\"hi, there\"\"\""), json!("hi, there"));
+        assert_eq!(parse_py_value("'x'"), json!("x"));
+        assert_eq!(parse_py_value("42"), json!(42));
+        assert_eq!(parse_py_value("true"), json!(true));
+        // A single top-level comma inside a triple-quoted string is not a split.
+        let args = parse_python_args("\"a\", \"\"\"b, c\"\"\"");
+        assert_eq!(args.len(), 2);
+        assert_eq!(args[0].1, json!("a"));
+        assert_eq!(args[1].1, json!("b, c"));
+        // kw_eq only fires before a string literal, not on `==` in content.
+        assert!(kw_eq_pos("contents=\"x\"").is_some());
+        assert!(kw_eq_pos("\"a == b\"").is_none());
+    }
     #[test]
     fn balanced_json_object_respects_strings_and_truncation() {
         assert_eq!(

package/harness/src/provider.rs CHANGED Viewed

@@ -195,6 +195,134 @@ pub fn stream(
     request(p, msgs, tools, true, on_text, on_thinking)
 }
+// A restrictive chat template (notably Gemma's on llama.cpp) rejected the
+// standard message roles: it can't render the `system`/`tool` roles or requires
+// strictly alternating user/assistant turns. Detected from the server's 400 so
+// the retry only fires for models that need it (qwen's template accepts them).
+fn is_template_role_error(e: &str) -> bool {
+    let l = e.to_lowercase();
+    l.contains("roles must alternate")
+        || l.contains("conversation roles")
+        || l.contains("unable to generate parser")
+        || l.contains("does not support")
+        || (l.contains("template") && l.contains("role"))
+}
+// Flatten a message's content (string or multimodal parts) to plain text.
+fn message_text(content: &Value) -> String {
+    if let Some(s) = content.as_str() {
+        return s.to_string();
+    }
+    if let Some(arr) = content.as_array() {
+        return arr
+            .iter()
+            .filter_map(|p| p["text"].as_str())
+            .collect::<Vec<_>>()
+            .join(" ");
+    }
+    String::new()
+}
+// Rewrite the request body's messages into the shape restrictive templates
+// accept: strictly alternating user/assistant with no `system`/`tool` roles.
+// System and tool-result content fold into user turns, an assistant turn's
+// tool_calls render as text, consecutive same-role turns merge, and the native
+// `tools` field is dropped — the model then emits tool_code/text calls, which
+// the agent's recovery parser handles.
+fn flatten_openai_messages(body: &mut Value) {
+    let Some(msgs) = body["messages"].as_array() else {
+        return;
+    };
+    let mut folded: Vec<(String, String)> = Vec::new();
+    for m in msgs {
+        let role = m["role"].as_str().unwrap_or("user");
+        let text = message_text(&m["content"]);
+        match role {
+            // Keep only the assistant's own prose. A prior tool_call is NOT
+            // rendered as text — a small model will imitate whatever call-shaped
+            // marker it sees and stop making real calls. The following "Tool
+            // result:" user turn already conveys what happened.
+            "assistant" => {
+                if !text.is_empty() {
+                    folded.push(("assistant".into(), text));
+                }
+            }
+            "tool" => {
+                if !text.is_empty() {
+                    folded.push(("user".into(), format!("Tool result:\n{text}")));
+                }
+            }
+            _ => folded.push(("user".into(), text)),
+        }
+    }
+    // Merge consecutive same-role turns so roles strictly alternate.
+    let mut merged: Vec<(String, String)> = Vec::new();
+    for (role, text) in folded {
+        if let Some(last) = merged.last_mut() {
+            if last.0 == role {
+                if !text.is_empty() {
+                    if !last.1.is_empty() {
+                        last.1.push_str("\n\n");
+                    }
+                    last.1.push_str(&text);
+                }
+                continue;
+            }
+        }
+        merged.push((role, text));
+    }
+    // These templates require the first turn to be `user`.
+    if merged.first().is_some_and(|(r, _)| r == "assistant") {
+        merged.insert(0, ("user".into(), String::new()));
+    }
+    body["messages"] = json!(merged
+        .iter()
+        .map(|(r, t)| json!({"role": r, "content": t}))
+        .collect::<Vec<_>>());
+    if let Some(obj) = body.as_object_mut() {
+        obj.remove("tools");
+    }
+}
+// Send an OpenAI-compatible request; on a template/role rejection, retry once
+// with a flattened, strictly-alternating message body.
+fn openai_exchange(
+    req: ureq::Request,
+    mut body: Value,
+    streaming: bool,
+    on_text: &mut dyn FnMut(&str),
+    on_thinking: &mut dyn FnMut(&str),
+) -> Result<Reply, String> {
+    if streaming {
+        body["stream"] = json!(true);
+    }
+    match send_raw(req.clone(), body.clone()) {
+        Ok(resp) => finish_openai(resp, streaming, on_text, on_thinking),
+        Err(e) if is_template_role_error(&e) => {
+            flatten_openai_messages(&mut body);
+            let resp = send_raw(req, body)?;
+            finish_openai(resp, streaming, on_text, on_thinking)
+        }
+        Err(e) => Err(e),
+    }
+}
+fn finish_openai(
+    resp: ureq::Response,
+    streaming: bool,
+    on_text: &mut dyn FnMut(&str),
+    on_thinking: &mut dyn FnMut(&str),
+) -> Result<Reply, String> {
+    if streaming {
+        openai_stream(resp.into_reader(), on_text, on_thinking)
+    } else {
+        let v = resp
+            .into_json::<Value>()
+            .map_err(|e| format!("bad JSON from server: {e}"))?;
+        openai_parse(v)
+    }
+}
 fn request(
     p: &Provider,
     msgs: &[Msg],
@@ -214,13 +342,8 @@ fn request(
             }
         }
         Protocol::OpenAi => {
-            let (req, mut body) = openai_request(p, msgs, tools);
-            if streaming {
-                body["stream"] = json!(true);
-                openai_stream(send_raw(req, body)?.into_reader(), on_text, on_thinking)
-            } else {
-                openai_parse(send(req, body)?)
-            }
+            let (req, body) = openai_request(p, msgs, tools);
+            openai_exchange(req, body, streaming, on_text, on_thinking)
         }
         Protocol::OllamaNative => {
             // The native path exists to set options.num_ctx (unavailable on
@@ -242,13 +365,8 @@ fn request(
                 None => {
                     warn_ollama_fallback();
                     let base = format!("{}/v1", ollama_root(&p.base_url));
-                    let (req, mut body) = openai_request_at(p, &base, msgs, tools);
-                    if streaming {
-                        body["stream"] = json!(true);
-                        openai_stream(send_raw(req, body)?.into_reader(), on_text, on_thinking)
-                    } else {
-                        openai_parse(send(req, body)?)
-                    }
+                    let (req, body) = openai_request_at(p, &base, msgs, tools);
+                    openai_exchange(req, body, streaming, on_text, on_thinking)
                 }
             }
         }
@@ -1520,6 +1638,67 @@ mod tests {
         );
     }
+    #[test]
+    fn template_role_error_detected() {
+        assert!(is_template_role_error(
+            "HTTP 400: Unable to generate parser for this template. Conversation roles must alternate user/assistant"
+        ));
+        assert!(!is_template_role_error("HTTP 500: internal error"));
+        assert!(!is_template_role_error("HTTP 429: rate limited"));
+    }
+    #[test]
+    fn flatten_messages_produces_alternating_user_assistant() {
+        // system, user, assistant(+tool_call), tool-result → must collapse to
+        // strictly alternating user/assistant with no system/tool roles.
+        let mut body = json!({
+            "model": "gemma",
+            "tools": [{"type": "function"}],
+            "messages": [
+                {"role": "system", "content": "You are helpful."},
+                {"role": "user", "content": "build it"},
+                {"role": "assistant", "content": "", "tool_calls": [
+                    {"id": "1", "type": "function", "function": {"name": "write_file", "arguments": "{\"path\":\"a\"}"}}
+                ]},
+                {"role": "tool", "tool_call_id": "1", "content": "wrote a"}
+            ]
+        });
+        flatten_openai_messages(&mut body);
+        let m = body["messages"].as_array().unwrap();
+        // The empty tool-call-only assistant turn is dropped (no call-shaped
+        // text for a small model to imitate), so the remaining turns are all
+        // user/assistant with none of the system/tool roles.
+        let roles: Vec<&str> = m.iter().map(|x| x["role"].as_str().unwrap()).collect();
+        assert!(roles.iter().all(|r| *r == "user" || *r == "assistant"));
+        let joined: String = m
+            .iter()
+            .map(|x| x["content"].as_str().unwrap_or(""))
+            .collect::<Vec<_>>()
+            .join("\n");
+        assert!(joined.contains("You are helpful"));
+        assert!(joined.contains("build it"));
+        assert!(joined.contains("Tool result"));
+        // A synthetic "[called …]" marker must never leak into the prompt.
+        assert!(!joined.contains("[called"));
+        // The native tools field is dropped for the restrictive template.
+        assert!(body.get("tools").is_none());
+    }
+    #[test]
+    fn flatten_messages_prepends_user_when_starting_on_assistant() {
+        let mut body = json!({
+            "messages": [{"role": "assistant", "content": "hi"}]
+        });
+        flatten_openai_messages(&mut body);
+        let roles: Vec<&str> = body["messages"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|x| x["role"].as_str().unwrap())
+            .collect();
+        assert_eq!(roles, vec!["user", "assistant"]);
+    }
     #[test]
     fn openai_body_tool_results_each_become_a_message() {
         let msgs = vec![Msg::Tool(vec![

package/harness/src/tools.rs CHANGED Viewed

@@ -318,11 +318,14 @@ pub fn defs_for_context(include_subagent: bool, context_tokens: usize) -> Vec<To
 }
 // The compact surface advertises one canonical tool per capability — read,
-// write, edit, shell, glob, grep, list, artifact publishing, plus the
-// finish/question control tools and python_tool for local extensions. Pure
-// aliases (`read`/`write`/`edit`/`bash`, `publish_artifact`) still dispatch in
-// `run` if a model insists, but advertising duplicates wastes prompt tokens
-// and confuses weak models. Keep this list at 12 defs or fewer.
+// write, edit, shell, glob, grep, list, artifact publishing, plus the finish
+// control tool and python_tool for local extensions. The `question` tool is
+// deliberately omitted: small models use it to stall (endlessly re-asking a
+// clarifying question instead of building), so on the compact surface they must
+// act on sensible defaults. Pure aliases (`read`/`write`/`edit`/`bash`,
+// `publish_artifact`) still dispatch in `run` if a model insists, but
+// advertising duplicates wastes prompt tokens and confuses weak models. Keep
+// this list at 12 defs or fewer.
 fn compact_tool(name: &str) -> bool {
     matches!(
         name,
@@ -334,7 +337,6 @@ fn compact_tool(name: &str) -> bool {
             | "grep_files"
             | "list_dir"
             | "finish"
-            | "question"
             | "Artifact"
             | "python_tool"
     )
@@ -1182,6 +1184,57 @@ fn first_local_script_src(contents: &str) -> Option<String> {
     None
 }
+// True if `val` is a local relative path (not an absolute URL or data: URI) —
+// such a reference won't exist next to a published single-file artifact.
+fn is_local_asset(val: &str) -> bool {
+    let v = val.trim().to_ascii_lowercase();
+    !v.is_empty()
+        && !v.starts_with("http://")
+        && !v.starts_with("https://")
+        && !v.starts_with("//")
+        && !v.starts_with("data:")
+}
+// Extract a (possibly quoted) attribute value from the text right after `attr=`.
+fn attr_after(after: &str) -> String {
+    let v = if let Some(rest) = after.strip_prefix('"') {
+        rest.split('"').next().unwrap_or("")
+    } else if let Some(rest) = after.strip_prefix('\'') {
+        rest.split('\'').next().unwrap_or("")
+    } else {
+        after
+            .split(|c: char| c.is_whitespace() || c == '>')
+            .next()
+            .unwrap_or("")
+    };
+    v.trim().to_string()
+}
+// A `<link rel="stylesheet" href="local.css">` pointing at a local file that
+// won't exist next to the published artifact. Returns the local href, else None.
+fn first_local_stylesheet_href(contents: &str) -> Option<String> {
+    let lower = contents.to_ascii_lowercase();
+    let mut at = 0;
+    while let Some(rel) = lower[at..].find("<link") {
+        let tag_start = at + rel;
+        let tag_end = lower[tag_start..]
+            .find('>')
+            .map(|e| tag_start + e)
+            .unwrap_or(lower.len());
+        let tag_lower = &lower[tag_start..tag_end];
+        if tag_lower.contains("stylesheet") {
+            if let Some(hp) = tag_lower.find("href=") {
+                let val = attr_after(&contents[tag_start + hp + "href=".len()..tag_end]);
+                if is_local_asset(&val) {
+                    return Some(val);
+                }
+            }
+        }
+        at = tag_end.max(tag_start + "<link".len());
+    }
+    None
+}
 // Rejection reasons for artifact contents. Every message quotes the offending
 // snippet and the exact rule, plus what to change — cheap models can't fix
 // what they can't see.
@@ -1196,7 +1249,12 @@ fn artifact_quality_error(contents: &str, kind: &str) -> Option<String> {
         let trimmed_len = contents.trim().len();
         if trimmed_len < 300 {
             return Some(format!(
-                "HTML artifact is too small to be a complete runnable app: {trimmed_len} chars, but the minimum is 300. Resend the artifact with the full HTML document — markup, embedded CSS, and embedded JavaScript — in `contents`."
+                "HTML artifact is too small to be a complete runnable app: {trimmed_len} chars, but the minimum is 300. It must be ONE self-contained file: do NOT link external files (no <link rel=stylesheet> or <script src=…>); put ALL CSS inside a <style> block and ALL JavaScript — the full working logic — inside a <script> block. Resend the complete document in `contents`."
+            ));
+        }
+        if let Some(href) = first_local_stylesheet_href(contents) {
+            return Some(format!(
+                "HTML artifact links a local stylesheet via <link rel=\"stylesheet\" href=\"{href}\">, which will not exist next to the published file. Move those styles into an inline <style>…</style> block so the artifact is self-contained."
             ));
         }
         if let Some(src) = first_local_script_src(contents) {
@@ -4570,7 +4628,6 @@ mod tests {
             "grep_files",
             "list_dir",
             "finish",
-            "question",
             "Artifact",
             "python_tool",
         ] {
@@ -4583,6 +4640,7 @@ mod tests {
             "kb_record",
             "verify",
             "text_editor_20250124",
+            "question",
             "AskUserQuestion",
             "read",
             "write",
@@ -5411,6 +5469,53 @@ print("hello " + data.get("name", "world"))
         let _ = fs::remove_dir_all(&d);
     }
+    #[test]
+    fn artifact_rejects_local_stylesheet_link() {
+        let d = tempdir();
+        // A 1.5B model's canvas-game stub linked <link rel=stylesheet href=styles.css>;
+        // it must be rejected with a message naming the file and telling the
+        // model to inline the CSS.
+        let body = html_app("draw();").replace(
+            "<head>",
+            "<head><link rel=\"stylesheet\" href=\"styles.css\">",
+        );
+        let r = run(
+            "Artifact",
+            &json!({"title": "Game", "contents": body, "type": "html"}),
+            &d,
+        );
+        assert!(r.is_error);
+        assert!(r.content.contains("styles.css"), "{}", r.content);
+        assert!(r.content.contains("<style"), "{}", r.content);
+        let _ = fs::remove_dir_all(&d);
+    }
+    #[test]
+    fn artifact_allows_external_stylesheet_link() {
+        let d = tempdir();
+        let body = html_app("draw();").replace(
+            "<head>",
+            "<head><link rel=\"stylesheet\" href=\"https://cdn.example.com/x.css\">",
+        );
+        let r = run(
+            "Artifact",
+            &json!({"title": "Game", "contents": body, "type": "html"}),
+            &d,
+        );
+        assert!(!r.is_error, "{}", r.content);
+        let _ = fs::remove_dir_all(&d);
+    }
+    #[test]
+    fn is_local_asset_classifies_paths() {
+        assert!(is_local_asset("styles.css"));
+        assert!(is_local_asset("./css/app.css"));
+        assert!(!is_local_asset("https://x.com/a.css"));
+        assert!(!is_local_asset("//cdn/a.css"));
+        assert!(!is_local_asset("data:text/css,body{}"));
+        assert!(!is_local_asset(""));
+    }
     #[test]
     fn artifact_allows_external_script_src() {
         let d = tempdir();

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "buildwithnexus",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "description": "A hilariously fast, agentic AI CLI harness in Rust — remote (API key) or local models, full-screen TUI with sessions, plan/build/brainstorm modes, and hooks",
   "bin": {
     "buildwithnexus": "bin/buildwithnexus.js",