Deduplicate file re-reads via content hashing for local and sandbox tools

agent/core/session.py

@@ -12,6 +12,7 @@ from typing import Any, Optional
 
 from agent.config import Config
 from agent.context_manager.manager import ContextManager
+from agent.tools.file_content_cache import FileContentCache
 
 logger = logging.getLogger(__name__)
 
@@ -105,6 +106,8 @@ class Session:
         self.sandbox = None
         self._running_job_ids: set[str] = set()  # HF job IDs currently executing
 
+        self.file_content_cache = FileContentCache()
+
         # Session trajectory logging
         self.logged_events: list[dict] = []
         self.session_start_time = datetime.now().isoformat()

agent/tools/file_content_cache.py

@@ -0,0 +1,40 @@
+"""Cache for detecting unchanged local file re-reads."""
+
+from __future__ import annotations
+
+import hashlib
+
+
+def _short_hash(content: str) -> str:
+    return hashlib.sha256(content.encode()).hexdigest()[:16]
+
+
+def _resolve(path: str) -> str:
+    try:
+        from pathlib import Path
+        return str(Path(path).resolve())
+    except Exception:
+        return path
+
+
+class FileContentCache:
+    """Tracks file content hashes to skip re-reading unchanged files."""
+
+    def __init__(self) -> None:
+        self._cache: dict[str, tuple[str, int]] = {}
+
+    def record_read(self, path: str, content: str, turn: int) -> None:
+        key = _resolve(path)
+        self._cache[key] = (_short_hash(content), turn)
+
+    def check_unchanged(self, path: str, content: str) -> tuple[bool, int | None]:
+        key = _resolve(path)
+        cached = self._cache.get(key)
+        if cached is None:
+            return False, None
+        cached_hash, turn = cached
+        return _short_hash(content) == cached_hash, turn
+
+    def clear_path(self, path: str) -> None:
+        key = _resolve(path)
+        self._cache.pop(key, None)

agent/tools/local_tools.py

@@ -119,10 +119,23 @@ async def _read_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]:
     if p.is_dir():
         return "Cannot read a directory. Use bash with 'ls' instead.", False
     try:
-        lines = p.read_text().splitlines()
+        raw_content = p.read_text()
     except Exception as e:
         return f"read error: {e}", False
 
+    # Check if file is unchanged since last read
+    session = _kw.get("session")
+    if session is not None:
+        is_unchanged, last_turn = session.file_content_cache.check_unchanged(
+            file_path, raw_content
+        )
+        if is_unchanged:
+            return (
+                f"[File unchanged since turn {last_turn}, "
+                f"content already in context.]"
+            ), True
+
+    lines = raw_content.splitlines()
     offset = max((args.get("offset") or 1), 1)
     limit = args.get("limit") or DEFAULT_READ_LINES
 
@@ -132,6 +145,12 @@ async def _read_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]:
         if len(line) > MAX_LINE_LENGTH:
             line = line[:MAX_LINE_LENGTH] + "..."
         numbered.append(f"{i:>6}\t{line}")
+
+    if session is not None:
+        session.file_content_cache.record_read(
+            file_path, raw_content, session.turn_count
+        )
+
     return "\n".join(numbered), True
 
 
@@ -143,6 +162,9 @@ async def _write_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]:
     p = Path(file_path)
     try:
         _atomic_write(p, content)
+        session = _kw.get("session")
+        if session is not None:
+            session.file_content_cache.clear_path(file_path)
         msg = f"Wrote {len(content)} bytes to {file_path}"
         # Syntax validation for Python files
         if p.suffix == ".py":
@@ -190,6 +212,10 @@ async def _edit_handler(args: dict[str, Any], **_kw) -> tuple[str, bool]:
     except Exception as e:
         return f"edit write error: {e}", False
 
+    session = _kw.get("session")
+    if session is not None:
+        session.file_content_cache.clear_path(file_path)
+
     msg = f"Edited {file_path} ({replacements} replacement{'s' if replacements > 1 else ''})"
     if fuzzy_note:
         msg += f" {fuzzy_note}"

agent/tools/sandbox_tool.py

@@ -244,7 +244,27 @@ def _make_tool_handler(sandbox_tool_name: str):
         try:
             result = await asyncio.to_thread(sb.call_tool, sandbox_tool_name, args)
             if result.success:
-                return result.output or "(no output)", True
+                output = result.output or "(no output)"
+                cache = getattr(session, "file_content_cache", None)
+                file_path = args.get("path", "")
+
+                if sandbox_tool_name == "read" and cache and file_path:
+                    is_unchanged, last_turn = cache.check_unchanged(
+                        f"sandbox:{file_path}", output
+                    )
+                    if is_unchanged:
+                        return (
+                            f"[File unchanged since turn {last_turn}, "
+                            f"content already in context.]"
+                        ), True
+                    cache.record_read(
+                        f"sandbox:{file_path}", output, session.turn_count
+                    )
+
+                if sandbox_tool_name in ("write", "edit") and cache and file_path:
+                    cache.clear_path(f"sandbox:{file_path}")
+
+                return output, True
             else:
                 error_msg = result.error or "Unknown error"
                 output = result.output