Allow private HTTP core URLs (#1765)

src/openhuman/memory/tree/ingest.rs

@@ -368,7 +368,7 @@ fn markdown_body_preview(md: &str) -> String {
     if len <= BODY_PREVIEW_MAX_BYTES {
         md.to_string()
     } else {
-        let start = md.ceil_char_boundary(len - BODY_PREVIEW_MAX_BYTES);
+        let start = crate::openhuman::util::ceil_char_boundary(md, len - BODY_PREVIEW_MAX_BYTES);
         md[start..].to_string()
     }
 }

src/openhuman/tools/impl/browser/screenshot.rs

@@ -152,7 +152,10 @@ impl ScreenshotTool {
                 let size = bytes.len();
                 let mut encoded = base64::engine::general_purpose::STANDARD.encode(&bytes);
                 let truncated = if encoded.len() > MAX_BASE64_BYTES {
-                    encoded.truncate(encoded.floor_char_boundary(MAX_BASE64_BYTES));
+                    encoded.truncate(crate::openhuman::util::floor_char_boundary(
+                        &encoded,
+                        MAX_BASE64_BYTES,
+                    ));
                     true
                 } else {
                     false

src/openhuman/tools/impl/system/node_exec.rs

@@ -223,11 +223,17 @@ impl Tool for NodeExecTool {
                 let mut stderr = String::from_utf8_lossy(&output.stderr).to_string();
 
                 if stdout.len() > MAX_OUTPUT_BYTES {
-                    stdout.truncate(stdout.floor_char_boundary(MAX_OUTPUT_BYTES));
+                    stdout.truncate(crate::openhuman::util::floor_char_boundary(
+                        &stdout,
+                        MAX_OUTPUT_BYTES,
+                    ));
                     stdout.push_str("\n... [stdout truncated at 1MB]");
                 }
                 if stderr.len() > MAX_OUTPUT_BYTES {
-                    stderr.truncate(stderr.floor_char_boundary(MAX_OUTPUT_BYTES));
+                    stderr.truncate(crate::openhuman::util::floor_char_boundary(
+                        &stderr,
+                        MAX_OUTPUT_BYTES,
+                    ));
                     stderr.push_str("\n... [stderr truncated at 1MB]");
                 }
 

src/openhuman/tools/impl/system/npm_exec.rs

@@ -235,11 +235,17 @@ impl Tool for NpmExecTool {
                 let mut stderr = String::from_utf8_lossy(&output.stderr).to_string();
 
                 if stdout.len() > MAX_OUTPUT_BYTES {
-                    stdout.truncate(stdout.floor_char_boundary(MAX_OUTPUT_BYTES));
+                    stdout.truncate(crate::openhuman::util::floor_char_boundary(
+                        &stdout,
+                        MAX_OUTPUT_BYTES,
+                    ));
                     stdout.push_str("\n... [stdout truncated at 1MB]");
                 }
                 if stderr.len() > MAX_OUTPUT_BYTES {
-                    stderr.truncate(stderr.floor_char_boundary(MAX_OUTPUT_BYTES));
+                    stderr.truncate(crate::openhuman::util::floor_char_boundary(
+                        &stderr,
+                        MAX_OUTPUT_BYTES,
+                    ));
                     stderr.push_str("\n... [stderr truncated at 1MB]");
                 }
 

src/openhuman/tools/impl/system/shell.rs

@@ -175,11 +175,17 @@ impl Tool for ShellTool {
 
                 // Truncate output to prevent OOM
                 if stdout.len() > MAX_OUTPUT_BYTES {
-                    stdout.truncate(stdout.floor_char_boundary(MAX_OUTPUT_BYTES));
+                    stdout.truncate(crate::openhuman::util::floor_char_boundary(
+                        &stdout,
+                        MAX_OUTPUT_BYTES,
+                    ));
                     stdout.push_str("\n... [output truncated at 1MB]");
                 }
                 if stderr.len() > MAX_OUTPUT_BYTES {
-                    stderr.truncate(stderr.floor_char_boundary(MAX_OUTPUT_BYTES));
+                    stderr.truncate(crate::openhuman::util::floor_char_boundary(
+                        &stderr,
+                        MAX_OUTPUT_BYTES,
+                    ));
                     stderr.push_str("\n... [stderr truncated at 1MB]");
                 }
 

src/openhuman/tree_summarizer/engine.rs

@@ -408,7 +408,8 @@ async fn summarize_to_limit(
             char_limit
         );
         // Truncate at a char boundary
-        let truncated = &response[..response.floor_char_boundary(char_limit)];
+        let truncated =
+            &response[..crate::openhuman::util::floor_char_boundary(&response, char_limit)];
         truncated.to_string()
     } else {
         response

src/openhuman/util.rs

@@ -79,6 +79,18 @@ pub fn floor_char_boundary(s: &str, index: usize) -> usize {
     end
 }
 
+/// Round a byte index UP to the nearest UTF-8 character boundary.
+pub fn ceil_char_boundary(s: &str, index: usize) -> usize {
+    if index >= s.len() {
+        return s.len();
+    }
+    let mut start = index;
+    while start < s.len() && !s.is_char_boundary(start) {
+        start += 1;
+    }
+    start
+}
+
 /// Utility enum for handling optional values.
 pub enum MaybeSet<T> {
     Set(T),
@@ -215,6 +227,19 @@ mod tests {
         assert_eq!(floor_char_boundary(s, 100), 6);
     }
 
+    #[test]
+    fn test_ceil_char_boundary() {
+        let s = "A🦀C";
+        assert_eq!(ceil_char_boundary(s, 0), 0);
+        assert_eq!(ceil_char_boundary(s, 1), 1); // After 'A'
+        assert_eq!(ceil_char_boundary(s, 2), 5); // Mid-🦀
+        assert_eq!(ceil_char_boundary(s, 3), 5); // Mid-🦀
+        assert_eq!(ceil_char_boundary(s, 4), 5); // Mid-🦀
+        assert_eq!(ceil_char_boundary(s, 5), 5); // After '🦀'
+        assert_eq!(ceil_char_boundary(s, 6), 6); // After 'C'
+        assert_eq!(ceil_char_boundary(s, 100), 6);
+    }
+
     #[test]
     fn test_truncate_with_suffix() {
         let s = "Hello World";