fix: address second-round review feedback on tinytools PR #1

- permission/test.rs: pin the exact serialized wire string for each
  PermissionLevel (in both directions), not just a round-trip, so a
  future serde rename fails the test instead of silently changing what
  gets persisted in a transcript or RPC payload
- naming/types.rs: a zero (or otherwise degenerate) max_chars truncated
  a genuinely present value down to an empty string and still returned
  Some(""); treat an empty render the same as no detail and return None,
  with a regression test
- README.md, lib.rs: replace the panicking args["text"] index in the
  Tool example with a safe get().and_then() chain, so the example
  doesn't train tool authors toward indexing into untrusted JSON

Co-authored-by: Medulla <medulla@tinyhumans.ai>

Author: senamakel

README.md

@@ -20,7 +20,8 @@ impl Tool for Echo {
         })
     }
     async fn execute(&self, args: serde_json::Value) -> anyhow::Result<ToolResult> {
-        Ok(ToolResult::success(args["text"].as_str().unwrap_or_default()))
+        let text = args.get("text").and_then(|v| v.as_str()).unwrap_or("");
+        Ok(ToolResult::success(text))
     }
 }
 ```

crates/tinytools/src/lib.rs

@@ -75,7 +75,7 @@
 //!     }
 //!
 //!     async fn execute(&self, args: serde_json::Value) -> anyhow::Result<ToolResult> {
-//!         let text = args["text"].as_str().unwrap_or_default();
+//!         let text = args.get("text").and_then(|v| v.as_str()).unwrap_or("");
 //!         Ok(ToolResult::success(text))
 //!     }
 //! }

crates/tinytools/src/naming/test.rs

@@ -114,6 +114,18 @@ fn an_ellipsis_longer_than_the_cap_cannot_overflow_it() {
     assert_eq!(detail.chars().count(), 2);
 }
 
+#[test]
+fn a_zero_cap_yields_no_detail_rather_than_a_blank_one() {
+    // A degenerate `max_chars` of 0 truncates a genuinely present value down to
+    // nothing; that must read as "no detail", not as "a detail, and it's
+    // empty" (`Some("")`), which a caller could render as a hollow decoration.
+    let detail = context_detail_from_args_with(
+        &json!({ "query": "hello" }),
+        ContextDetailOptions::new(0, "..."),
+    );
+    assert_eq!(detail, None);
+}
+
 #[test]
 fn the_default_options_are_eighty_chars_and_three_dots() {
     let defaults = ContextDetailOptions::default();

crates/tinytools/src/naming/types.rs

@@ -149,16 +149,27 @@ fn render_context_value(value: &Value, options: ContextDetailOptions) -> Option<
     if raw.is_empty() {
         return None;
     }
-    if raw.chars().count() > options.max_chars {
+    let rendered = if raw.chars().count() > options.max_chars {
         // Clamp the ellipsis itself to `max_chars` first: an ellipsis longer
         // than the cap (a misconfigured caller) would otherwise survive
         // `saturating_sub`'s zero and still be appended in full, pushing the
         // rendered value past the cap it was supposed to enforce.
         let ellipsis: String = options.ellipsis.chars().take(options.max_chars).collect();
         let keep = options.max_chars.saturating_sub(ellipsis.chars().count());
         let truncated: String = raw.chars().take(keep).collect();
-        Some(format!("{truncated}{ellipsis}"))
+        format!("{truncated}{ellipsis}")
     } else {
-        Some(raw)
+        raw
+    };
+
+    // A zero (or otherwise degenerate) `max_chars` can truncate a genuinely
+    // present, nonempty value down to nothing. Callers distinguish `None` (no
+    // detail to show) from `Some(String)` (a detail to render), so surfacing
+    // `Some("")` here would read as "there is a detail, and it's blank" rather
+    // than "there is no detail" — treat an empty render the same as absence.
+    if rendered.is_empty() {
+        None
+    } else {
+        Some(rendered)
     }
 }

crates/tinytools/src/permission/test.rs

@@ -40,3 +40,26 @@ fn levels_round_trip_through_json() {
         assert_eq!(back, level);
     }
 }
+
+#[test]
+fn levels_are_pinned_to_their_exact_wire_names() {
+    // A round-trip alone only proves the encoder and decoder currently agree
+    // with *each other* — it still passes if a `serde` rename quietly changes
+    // what gets persisted. Pin the literal strings, in both directions, so a
+    // rename that would silently corrupt an on-disk transcript or an RPC
+    // payload already carrying `"ReadOnly"` fails here instead.
+    let cases = [
+        (PermissionLevel::None, "\"None\""),
+        (PermissionLevel::ReadOnly, "\"ReadOnly\""),
+        (PermissionLevel::Write, "\"Write\""),
+        (PermissionLevel::Execute, "\"Execute\""),
+        (PermissionLevel::Dangerous, "\"Dangerous\""),
+    ];
+    for (level, wire) in cases {
+        assert_eq!(serde_json::to_string(&level).expect("serializable"), wire);
+        assert_eq!(
+            serde_json::from_str::<PermissionLevel>(wire).expect("deserializable"),
+            level
+        );
+    }
+}