v0.14.4 apiproxy HOTFIX: stop poisoning tool_use input dict shape

Previous v0.14.3 replaced the entire tool_use.input dict with
{"_omc_compressed_input_marker": "..."}. The LLM then saw this in
conversation history and started copying the pattern when generating
new tool calls, producing InputValidationError on every Edit/Bash call.

Fix: rewrite_strings_recursive walks the input value and replaces only
LARGE STRING VALUES in place, preserving the original key names. So
{"file_path": "/x", "content": "<2KB>"} becomes
{"file_path": "/x", "content": "<omc:ref/>"} — recognizable as a
normal Write call by the LLM, no fake schema introduced.

Also dropped marker `preview` field for blocks >= 8KB. At that size the
LLM either needs the whole thing (expand-tool) or skips it; preview
adds zero decision-quality and ~200B per marker.

Verified in isolation against mock upstream:
  - tool_use.input keeps `file_path` and `content` keys intact
  - tool_result.content rewritten to marker
  - last user message untouched (existing safety rule)
  - upstream-visible payload preserves the assistant's tool-calling shape

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

omnimcode-apiproxy/src/main.rs

@@ -548,23 +548,12 @@ fn rewrite_request_body(body: &[u8], state: &AppState) -> Result<(Bytes, Rewrite
                             }
                         }
                         "tool_use" => {
-                            // Compress big `input` JSON (e.g., Write/Edit
-                            // calls where the LLM emitted file content).
+                            // Compress big string values INSIDE the input dict.
+                            // Crucially, preserve the original key names so the
+                            // LLM doesn't see (and thus copy) a fake field name
+                            // when generating fresh tool calls in later turns.
                             if let Some(input) = block.get_mut("input") {
-                                let serialized = serde_json::to_string(input)
-                                    .unwrap_or_default();
-                                if serialized.len() >= state.rewrite_threshold {
-                                    if let Ok(marker) = make_marker(&serialized, state) {
-                                        out.bytes_tool_use_input += serialized.len();
-                                        out.rewritten_count += 1;
-                                        // Wrap marker as an object so the JSON
-                                        // remains structurally an object — many
-                                        // LLM clients assume `input` is a dict.
-                                        *input = serde_json::json!({
-                                            "_omc_compressed_input_marker": marker
-                                        });
-                                    }
-                                }
+                                rewrite_strings_recursive(input, state, &mut out);
                             }
                         }
                         _ => {}
@@ -582,6 +571,42 @@ fn rewrite_request_body(body: &[u8], state: &AppState) -> Result<(Bytes, Rewrite
     Ok((bytes, out))
 }
 
+/// v0.14.4 — walk a JSON value and replace any large STRING values in place,
+/// preserving all key names so the LLM doesn't see (and copy) a fake field
+/// name when generating new tool calls. Used for `tool_use.input`.
+///
+/// Two layers of value-rewriting:
+///   1. A top-level string longer than threshold → marker.
+///   2. Any string FIELD inside an object whose value exceeds threshold →
+///      marker (e.g. `{"content": "...big..."} → {"content": "<omc:ref ...>"}`).
+///   3. Array elements that are strings → same rule, in place.
+fn rewrite_strings_recursive(
+    val: &mut Value, state: &AppState, out: &mut RewriteOutcome,
+) {
+    match val {
+        Value::String(s) => {
+            if s.len() >= state.rewrite_threshold {
+                if let Ok(marker) = make_marker(s, state) {
+                    out.bytes_tool_use_input += s.len();
+                    out.rewritten_count += 1;
+                    *val = Value::String(marker);
+                }
+            }
+        }
+        Value::Object(map) => {
+            for (_k, v) in map.iter_mut() {
+                rewrite_strings_recursive(v, state, out);
+            }
+        }
+        Value::Array(arr) => {
+            for v in arr.iter_mut() {
+                rewrite_strings_recursive(v, state, out);
+            }
+        }
+        _ => {}
+    }
+}
+
 fn rewrite_tool_result_content(
     inner: &mut Value, state: &AppState, out: &mut RewriteOutcome,
 ) {
@@ -614,13 +639,16 @@ fn rewrite_tool_result_content(
 fn make_marker(text: &str, state: &AppState) -> Result<String> {
     let hash = state.store.store(PROXY_CACHE_NAMESPACE, text)
         .map_err(anyhow::Error::msg)?;
+    // For very large blocks the LLM almost certainly wants either:
+    // (a) the full content (expand via tool), or (b) to move on.
+    // The preview adds no decision-quality. Drop it past 8 KB.
+    if text.len() >= 8192 {
+        return Ok(format!("<omc:ref h=\"{}\" b=\"{}\"/>", hash, text.len()));
+    }
     let preview: String = text.chars()
         .filter(|c| !c.is_control())
         .take(state.preview_bytes)
         .collect();
-    // The marker uses an XML-ish form because LLMs are well-trained on
-    // tagged content and don't try to "interpret" attribute values as
-    // executable. The proxy's expand tool is the LLM's way out.
     Ok(format!(
         "<omc:ref hash_str=\"{}\" bytes=\"{}\" preview={:?}/>",
         hash, text.len(), preview