1. 1use async_trait::async_trait;
2. 2use serde_json::Value;
3. 3
4. 4use crate::{Tool, ToolContext, ToolOutput};
5. 5
6. 6const DEFAULT_LIMIT: usize = 2000;
7. 7const IMAGE_EXTS: [&str; 5] = ["jpg", "jpeg", "png", "gif", "webp"];
8. 8
9. 9pub struct ReadTool;
10. 10
11. 11#[async_trait]
12. 12impl Tool for ReadTool {
13. 13 fn name(&self) -> &str {
14. 14 "read"
15. 15 }
16. 16
17. 17 fn serves(&self) -> &'static [&'static str] {
18. 18 &["filesystem"]
19. 19 }
20. 20
21. 21 fn always_loaded(&self) -> bool {
22. 22 true
23. 23 }
24. 24
25. 25 fn description(&self) -> &str {
26. 26 "Read a text file from disk. Returns numbered lines. Use offset/limit to page through large files. For Word, Excel, PowerPoint and Visio files use doc_read."
27. 27 }
28. 28
29. 29 fn schema(&self) -> Value {
30. 30 serde_json::json!({
31. 31 "type": "object",
32. 32 "properties": {
33. 33 "path": {"type": "string", "description": "File path (relative to cwd or absolute)"},
34. 34 "offset": {"type": "integer", "minimum": 1, "description": "1-based start line"},
35. 35 "limit": {"type": "integer", "minimum": 1, "description": "Max lines to return"}
36. 36 },
37. 37 "required": ["path"]
38. 38 })
39. 39 }
40. 40
41. 41 fn refusal(&self, args: &Value) -> Option<String> {
42. 42 let path = args.get("path").and_then(Value::as_str)?;
43. 43 crate::office_apply::text_tool_refusal(std::path::Path::new(path), "read")
44. 44 }
45. 45
46. 46 fn claims(&self, _args: &Value) -> crate::ResourceClaims {
47. 47 crate::ResourceClaims {
48. 48 exclusive: false,
49. 49 read_only: true,
50. 50 paths: Vec::new(),
51. 51 }
52. 52 }
53. 53
54. 54 async fn execute(&self, args: &Value, ctx: &ToolContext) -> ToolOutput {
55. 55 let Some(path_str) = args.get("path").and_then(|p| p.as_str()) else {
56. 56 return ToolOutput::error("missing required parameter: path");
57. 57 };
58. 58 let path = ctx.resolve(std::path::Path::new(path_str));
59. 59 if let Some(refusal) = crate::office_apply::text_tool_refusal(&path, "read") {
60. 60 return ToolOutput::error(refusal);
61. 61 }
62. 62
63. 63 let ext = path
64. 64 .extension()
65. 65 .and_then(|e| e.to_str())
66. 66 .map(|e| e.to_ascii_lowercase())
67. 67 .unwrap_or_default();
68. 68 if IMAGE_EXTS.contains(&ext.as_str()) {
69. 69 return ToolOutput::ok(format!(
70. 70 "[image file: {} — inline image rendering is not enabled in this build]",
71. 71 path.display()
72. 72 ));
73. 73 }
74. 74
75. 75 let bytes = match tokio::fs::read(&path).await {
76. 76 Ok(b) => b,
77. 77 Err(e) => return ToolOutput::error(format!("cannot read {}: {e}", path.display())),
78. 78 };
79. 79 if bytes.iter().take(8192).any(|&b| b == 0) {
80. 80 return ToolOutput::ok(format!("[binary file: {}]", path.display()));
81. 81 }
82. 82
83. 83 let text = String::from_utf8_lossy(&bytes);
84. 84 let total_lines = text.lines().count();
85. 85 let offset = args
86. 86 .get("offset")
87. 87 .and_then(|o| o.as_u64())
88. 88 .unwrap_or(1)
89. 89 .max(1) as usize;
90. 90 let limit = args
91. 91 .get("limit")
92. 92 .and_then(|l| l.as_u64())
93. 93 .map(|l| l as usize)
94. 94 .unwrap_or(DEFAULT_LIMIT);
95. 95
96. 96 let start_idx = offset - 1;
97. 97 if start_idx >= total_lines {
98. 98 return ToolOutput::error(format!(
99. 99 "offset {offset} is beyond end of file ({total_lines} lines)"
100. 100 ));
101. 101 }
102. 102 let end_idx = (start_idx + limit).min(total_lines);
103. 103
104. 104 let mut out = String::new();
105. 105 for (i, line) in text
106. 106 .lines()
107. 107 .enumerate()
108. 108 .skip(start_idx)
109. 109 .take(end_idx - start_idx)
110. 110 {
111. 111 out.push_str(&format!("{:>6}\t{line}\n", i + 1));
112. 112 }
113. 113 if end_idx < total_lines {
114. 114 out.push_str(&format!(
115. 115 "\n[Showing lines {}–{} of {total_lines}. Use offset={} to continue.]\n",
116. 116 start_idx + 1,
117. 117 end_idx,
118. 118 end_idx + 1
119. 119 ));
120. 120 }
121. 121 ToolOutput::ok(out)
122. 122 }
123. 123}
124. 124