codeplain 0.3.11.dev19__py3-none-any.whl → 0.3.11.dev20__py3-none-any.whl

render_machine/agent_tools.py

@@ -0,0 +1,270 @@
+"""Client-side implementations of the tools a server-side agent can call.
+
+The server declares the tools to the LLM (codeplain-api: src/agent/tools.py) and forwards
+the model's calls; this module executes them against the local build folder and returns
+plain-text results. Relative paths resolve against the build folder. Reads are allowed only in the
+build folder and the full test logs the agent was pointed to; writes only inside the build folder.
+"""
+
+import glob
+import json
+import os
+import subprocess
+import tempfile
+from typing import Callable
+
+from plain2code_console import console
+from render_machine import render_utils
+from render_machine.render_context import RenderContext
+
+DEFAULT_READ_LIMIT = 200
+MAX_LINE_CHARS = 10_000
+MAX_OUTPUT_CHARS = 30_000
+EDIT_SNIPPET_CONTEXT_LINES = 3
+MAX_EDIT_SNIPPET_LINES = 60
+MAX_GREP_CONTEXT_LINES = 20
+# Tools without side effects; repeating one while no file changed returns a pointer instead.
+READ_ONLY_TOOLS = ("read_file", "grep", "ls_files")
+GREP_EXCLUDED_DIRS = (".git", "__pycache__", "node_modules", ".venv", "target", "dist", "build")
+
+
+def _build_folder(render_context: RenderContext) -> str:
+    return os.path.normpath(os.path.abspath(render_context.build_folder))
+
+
+def _resolve(file_path: str, render_context: RenderContext) -> str:
+    if os.path.isabs(file_path):
+        return os.path.normpath(file_path)
+    return os.path.normpath(os.path.join(_build_folder(render_context), file_path))
+
+
+def _within(path: str, folder: str) -> bool:
+    return path == folder or path.startswith(folder + os.sep)
+
+
+def _readable(path: str, render_context: RenderContext) -> bool:
+    return (
+        _within(path, _build_folder(render_context))
+        or path in render_context.unit_tests_agent_session.readable_log_paths
+    )
+
+
+def register_log_path(log_path: str, render_context: RenderContext) -> None:
+    """Allow read_file/grep on a full test log the agent is pointed to."""
+    render_context.unit_tests_agent_session.readable_log_paths.add(os.path.normpath(os.path.abspath(log_path)))
+
+
+def _writable(path: str, render_context: RenderContext) -> bool:
+    return _within(path, _build_folder(render_context))
+
+
+def _bound(text: str) -> str:
+    """Cap very long lines and the total size so one tool result cannot flood the context."""
+    lines = [
+        line if len(line) <= MAX_LINE_CHARS else line[:MAX_LINE_CHARS] + "... [line truncated]"
+        for line in text.split("\n")
+    ]
+    text = "\n".join(lines)
+    if len(text) > MAX_OUTPUT_CHARS:
+        head, tail = int(MAX_OUTPUT_CHARS * 0.6), int(MAX_OUTPUT_CHARS * 0.4)
+        text = text[:head] + f"\n\n... [truncated {len(text) - head - tail:,} chars] ...\n\n" + text[-tail:]
+    return text
+
+
+def _track_change(full_path: str, render_context: RenderContext) -> None:
+    context = render_context.unit_tests_running_context
+    context.changed_files.add(os.path.relpath(full_path, _build_folder(render_context)))
+    context.verified_passing, context.verified_passing_log_path = False, None
+    context.tool_result_cache.clear()
+
+
+def read_file(args: dict, render_context: RenderContext) -> str:
+    full_path = _resolve(args.get("file_path", ""), render_context)
+    if not _readable(full_path, render_context):
+        return f"Error: read access denied for '{full_path}' (readable: build folder and test logs)."
+    if not os.path.isfile(full_path):
+        return f"Error: file not found: '{full_path}'."
+    with open(full_path, "r", encoding="utf-8", errors="replace") as f:
+        lines = f.read().split("\n")
+    offset = max(int(args.get("offset") or 1), 1)
+    limit = int(args.get("limit") or DEFAULT_READ_LIMIT)
+    selected = lines[offset - 1 : offset - 1 + limit]
+    if not selected:
+        return f"Error: offset {offset} is past the end of the file ({len(lines)} lines)."
+    numbered = "\n".join(f"{offset + i}: {line}" for i, line in enumerate(selected))
+    last = offset - 1 + len(selected)
+    note = (
+        f"\n[showing lines {offset}-{last} of {len(lines)}; use offset={last + 1} to continue]"
+        if last < len(lines)
+        else ""
+    )
+    return _bound(numbered) + note
+
+
+def grep(args: dict, render_context: RenderContext) -> str:
+    pattern = args.get("pattern", "")
+    if not pattern:
+        return "Error: pattern is required."
+    target = _resolve(args.get("file_path") or ".", render_context)
+    if not _readable(target, render_context):
+        return f"Error: read access denied for '{target}'."
+    if not os.path.exists(target):
+        return f"Error: path not found: '{target}'."
+    # Run from the build folder so matches inside it come back as build-relative paths, which
+    # is the form the other tools accept; a test log outside it is passed by absolute path.
+    cwd = _build_folder(render_context)
+    options = [f"--exclude-dir={d}" for d in GREP_EXCLUDED_DIRS]
+    context_lines = min(max(int(args.get("context_lines") or 0), 0), MAX_GREP_CONTEXT_LINES)
+    if context_lines:
+        options.append(f"-C{context_lines}")
+    if args.get("include"):
+        options.append(f"--include={args['include']}")
+    command = ["grep", "-rnI", *options, "-e", pattern, "--"]
+    command.append(os.path.relpath(target, cwd) if _within(target, cwd) else target)
+    result = subprocess.run(command, capture_output=True, text=True, cwd=cwd)
+    if result.returncode == 1:
+        return f"No matches for '{pattern}' in '{target}'."
+    if result.returncode != 0:
+        return f"Error: grep failed: {result.stderr.strip()}"
+    lines = [line[2:] if line.startswith("./") else line for line in result.stdout.rstrip("\n").split("\n")]
+    return _bound("\n".join(lines))
+
+
+def ls_files(args: dict, render_context: RenderContext) -> str:
+    target = _resolve(args.get("pattern") or ".", render_context)
+    if not _readable(target, render_context):
+        return f"Error: read access denied for '{target}'."
+    if os.path.isdir(target):
+        entries = sorted(os.listdir(target))
+        listing = [entry + "/" if os.path.isdir(os.path.join(target, entry)) else entry for entry in entries]
+        return f"{target}:\n" + ("\n".join(listing) if listing else "(empty)")
+    matches = sorted(glob.glob(target, recursive=True))
+    return _bound("\n".join(matches)) if matches else f"No files match '{target}'."
+
+
+def edit_file(args: dict, render_context: RenderContext) -> str:
+    full_path = _resolve(args.get("file_path", ""), render_context)
+    search, replace = args.get("search", ""), args.get("replace", "")
+    if not search:
+        return "Error: search is required."
+    if not _writable(full_path, render_context):
+        return f"Error: write access denied for '{full_path}' (writable: build folder only)."
+    if not os.path.isfile(full_path):
+        return f"Error: file not found: '{full_path}'. Use write_file to create new files."
+    with open(full_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    occurrences = content.count(search)
+    if occurrences != 1:
+        return (
+            f"Error: search text found {occurrences} times in '{full_path}'; it must appear exactly once. "
+            "Read the file and use a larger, unique snippet."
+        )
+    with open(full_path, "w", encoding="utf-8") as f:
+        f.write(content.replace(search, replace, 1))
+    _track_change(full_path, render_context)
+    return f"Edited '{full_path}'. The edited region now reads:\n" + _edit_snippet(content, search, replace)
+
+
+def _edit_snippet(content: str, search: str, replace: str) -> str:
+    """Numbered lines of the replacement plus a little context, so the edit needs no re-read."""
+    lines = content.replace(search, replace, 1).split("\n")
+    first = content[: content.index(search)].count("\n")
+    last = first + replace.count("\n")
+    start = max(first - EDIT_SNIPPET_CONTEXT_LINES, 0)
+    end = min(last + EDIT_SNIPPET_CONTEXT_LINES + 1, len(lines), start + MAX_EDIT_SNIPPET_LINES)
+    snippet = "\n".join(f"{start + i + 1}: {line}" for i, line in enumerate(lines[start:end]))
+    return _bound(snippet)
+
+
+def write_file(args: dict, render_context: RenderContext) -> str:
+    full_path = _resolve(args.get("file_path", ""), render_context)
+    if not _writable(full_path, render_context):
+        return f"Error: write access denied for '{full_path}' (writable: build folder only)."
+    os.makedirs(os.path.dirname(full_path), exist_ok=True)
+    with open(full_path, "w", encoding="utf-8") as f:
+        f.write(args.get("content", ""))
+    _track_change(full_path, render_context)
+    return f"Wrote '{full_path}'."
+
+
+def delete_file(args: dict, render_context: RenderContext) -> str:
+    full_path = _resolve(args.get("file_path", ""), render_context)
+    if not _writable(full_path, render_context):
+        return f"Error: write access denied for '{full_path}' (writable: build folder only)."
+    if not os.path.isfile(full_path):
+        return f"Error: file not found: '{full_path}'."
+    os.remove(full_path)
+    _track_change(full_path, render_context)
+    return f"Deleted '{full_path}'."
+
+
+def full_log_pointer(log_file_path: str | None) -> str:
+    return f" Full log: {log_file_path} (search it with grep, passing that path as file_path)." if log_file_path else ""
+
+
+def run_unit_tests(_args: dict, render_context: RenderContext) -> dict:
+    """Returns a result dict: a short header in `output` and the raw failure output in
+    `test_output`, which the server condenses (summarizing it when it is long)."""
+    exit_code, output, log_file_path = render_utils.execute_script(
+        os.path.normpath(render_context.unittests_script),
+        [render_context.build_folder],
+        "Unit Tests",
+        timeout=render_context.test_script_timeout,
+        stop_event=render_context.stop_event,
+    )
+    context = render_context.unit_tests_running_context
+    if exit_code == 0:
+        context.verified_passing, context.verified_passing_log_path = True, log_file_path
+        return {"output": "All unit tests passed."}
+    if not log_file_path and output:
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False, suffix=".unittest_output") as f:
+            f.write(output)
+            log_file_path = f.name
+    if log_file_path:
+        register_log_path(log_file_path, render_context)
+    return {
+        "output": f"Unit tests failed (exit code {exit_code}).{full_log_pointer(log_file_path)}",
+        "test_output": output,
+    }
+
+
+TOOLS: dict[str, Callable[[dict, RenderContext], str | dict]] = {
+    "read_file": read_file,
+    "grep": grep,
+    "ls_files": ls_files,
+    "edit_file": edit_file,
+    "write_file": write_file,
+    "delete_file": delete_file,
+    "run_unit_tests": run_unit_tests,
+}
+
+
+def execute_calls(calls: list[dict], render_context: RenderContext) -> list[dict]:
+    """Execute the agent's tool calls in order; every call gets a result, errors included.
+
+    A repeated read-only call (same tool and arguments, no file changed in between) is not
+    re-executed: its result is already in the conversation, so a short pointer is returned."""
+    cache = render_context.unit_tests_running_context.tool_result_cache
+    results = []
+    for call in calls:
+        tool = TOOLS.get(call["name"])
+        cache_key = json.dumps([call["name"], call.get("args") or {}], sort_keys=True)
+        result: dict
+        if tool is None:
+            result = {"output": f"Error: unknown tool '{call['name']}'."}
+        elif call["name"] in READ_ONLY_TOOLS and cache_key in cache:
+            result = {
+                "output": "Same call as an earlier one and no file has changed since; "
+                "its result is unchanged (see the earlier result above)."
+            }
+        else:
+            try:
+                output = tool(call.get("args") or {}, render_context)
+                result = output if isinstance(output, dict) else {"output": output}
+            except Exception as e:
+                result = {"output": f"Error: tool '{call['name']}' failed: {type(e).__name__}: {e}"}
+            if call["name"] in READ_ONLY_TOOLS and not result["output"].startswith("Error"):
+                cache[cache_key] = result["output"]
+        console.debug(f"Agent tool {call['name']}({call.get('args')}) -> {result['output'][:200]!r}")
+        results.append({"call_id": call["id"], **result})
+    return results

render_machine/render_context.py

@@ -19,6 +19,7 @@ from render_machine.render_types import (
     FridContext,
     ScriptExecutionHistory,
     TestExecutionPhase,
+    UnitTestsAgentSession,
     UnitTestsRunningContext,
 )
 
@@ -188,6 +189,14 @@ class RenderContext:
     def should_run_conformance_tests(self) -> bool:
         return self.conformance_tests_script is not None
 
+    @property
+    def unit_tests_agent_session(self) -> UnitTestsAgentSession:
+        """The agent session fixing the unit tests: per unit-test loop, except during the conformance
+        phase, where one session spans every loop (see UnitTestsAgentSession)."""
+        if self.conformance_tests_running_context is not None:
+            return self.conformance_tests_running_context.unit_tests_agent_session
+        return self.unit_tests_running_context.agent_session
+
     def start_unittests_processing(self):
         self.unit_tests_running_context = UnitTestsRunningContext(fix_attempts=0)
         self.run_state.increment_unittest_batch_id()

render_machine/render_types.py

@@ -48,10 +48,53 @@ class FridContext:
     refactoring_iteration: int = 0
 
 
+@dataclass
+class UnitTestsAgentSession:
+    """Server-side agent session fixing a FRID's unit tests, and what it still has to be told.
+
+    Owned by the unit-tests running context (one session per unit-test loop) in the implementation
+    and refactoring phases, and by the conformance tests running context during the conformance
+    phase, so there one session spans every unit-test loop - the agent then sees that the
+    conformance tests fixer keeps changing the code it adjusts (see RenderContext.unit_tests_agent_session).
+    """
+
+    session_id: Optional[str] = None
+    # The submit_fix call the agent ended its last attempt with, answered with the next test
+    # run's outcome, plus results of any tool calls made in the same turn as submit_fix.
+    pending_submit_call_id: Optional[str] = None
+    pending_tool_results: list[dict] = field(default_factory=list)
+    # Session abandoned without a submission (turn budget used up, LLM failure); the next session
+    # starts with a digest of what it tried.
+    previous_session_id: Optional[str] = None
+    # Full test logs the agent was pointed to; readable by read_file/grep although outside the
+    # build folder.
+    readable_log_paths: set[str] = field(default_factory=set)
+    # How many of the conformance tests fixes (ConformanceTestsRunningContext.implementation_code_fixes)
+    # the session has already been shown.
+    conformance_fixes_handed_off: int = 0
+
+    def reset(self) -> None:
+        """Drop the session (keeping its id as the previous one) so the next failure starts a new one."""
+        self.previous_session_id = self.session_id
+        self.session_id, self.pending_submit_call_id, self.pending_tool_results = None, None, []
+        self.conformance_fixes_handed_off = 0
+
+
 @dataclass
 class UnitTestsRunningContext:
     fix_attempts: int
     changed_files: set[str] = field(default_factory=set)
+    # The agent session of this loop; used only outside the conformance phase.
+    agent_session: UnitTestsAgentSession = field(default_factory=UnitTestsAgentSession)
+    # Whether the agent already made a fix attempt in this loop. A session that is still open when
+    # a loop starts had its last fix accepted, which is what the agent is told.
+    agent_used_in_this_loop: bool = False
+    # Set when the agent's own run_unit_tests passed and no file changed since, so the harness
+    # can accept the fix without running the suite again.
+    verified_passing: bool = False
+    verified_passing_log_path: Optional[str] = None
+    # Results of read-only tool calls, keyed by call; cleared whenever a file changes.
+    tool_result_cache: dict[str, str] = field(default_factory=dict)
 
 
 class ConformanceTestsRunningContext:
@@ -95,6 +138,8 @@ class ConformanceTestsRunningContext:
         # order. Each entry is {"hypothesis": str | None, "approach": str | None, "code_diff": {file: diff}}.
         # Handed to the unit tests fixer so it adjusts the unit tests instead of reverting these changes.
         self.implementation_code_fixes: list[dict] = []
+        # The unit-test fixing agent session, shared by every unit-test loop of this conformance phase.
+        self.unit_tests_agent_session = UnitTestsAgentSession()
 
     def get_conformance_tests_json(self, module_name: str) -> dict:
         return self._conformance_tests_json[module_name]

tests/test_agent_tools.py

@@ -0,0 +1,166 @@
+"""Tests for the client-side agent tool implementations."""
+
+import os
+from types import SimpleNamespace
+
+import pytest
+
+from render_machine import agent_tools
+from render_machine.render_context import RenderContext
+from render_machine.render_types import UnitTestsRunningContext
+
+
+class FakeRenderContext(SimpleNamespace):
+    unit_tests_agent_session = RenderContext.unit_tests_agent_session
+
+
+@pytest.fixture
+def project(tmp_path, monkeypatch):
+    build = tmp_path / "plain_modules" / "m"
+    build.mkdir(parents=True)
+    (build / "app.py").write_text("def add(a, b):\n    return a - b\n\n\ndef sub(a, b):\n    return a - b\n")
+    (tmp_path / "outside.txt").write_text("outside\n")
+    monkeypatch.chdir(tmp_path)
+    render_context = FakeRenderContext(
+        build_folder=str(build),
+        unit_tests_running_context=UnitTestsRunningContext(fix_attempts=1),
+        conformance_tests_running_context=None,
+        unittests_script=None,
+        test_script_timeout=None,
+        stop_event=None,
+    )
+    return SimpleNamespace(root=tmp_path, build=build, rc=render_context)
+
+
+def test_read_file_resolves_relative_to_build_folder_with_paging(project):
+    out = agent_tools.read_file({"file_path": "app.py", "offset": 2, "limit": 1}, project.rc)
+    assert out.startswith("2:     return a - b")
+    assert "use offset=3 to continue" in out
+
+
+def test_read_is_confined_to_build_folder(project):
+    outside = str(project.root / "outside.txt")
+    assert agent_tools.read_file({"file_path": outside}, project.rc).startswith("Error: read access denied")
+    assert agent_tools.read_file({"file_path": "../../outside.txt"}, project.rc).startswith("Error: read access denied")
+    assert agent_tools.grep({"pattern": "outside", "file_path": outside}, project.rc).startswith("Error: read access")
+    assert agent_tools.ls_files({"pattern": str(project.root)}, project.rc).startswith("Error: read access denied")
+    assert agent_tools.read_file({"file_path": "/etc/hosts"}, project.rc).startswith("Error: read access denied")
+    assert agent_tools.read_file({"file_path": "missing.py"}, project.rc).startswith("Error: file not found")
+
+
+def test_edit_file_requires_unique_match_and_tracks_change(project):
+    ambiguous = agent_tools.edit_file({"file_path": "app.py", "search": "return a - b", "replace": "x"}, project.rc)
+    assert "found 2 times" in ambiguous
+    assert project.rc.unit_tests_running_context.changed_files == set()
+
+    ok = agent_tools.edit_file(
+        {
+            "file_path": "app.py",
+            "search": "def add(a, b):\n    return a - b",
+            "replace": "def add(a, b):\n    return a + b",
+        },
+        project.rc,
+    )
+    assert ok.startswith("Edited")
+    assert "return a + b" in (project.build / "app.py").read_text()
+    assert project.rc.unit_tests_running_context.changed_files == {"app.py"}
+
+
+def test_write_and_delete_are_confined_to_build_folder(project):
+    denied = agent_tools.write_file({"file_path": str(project.root / "evil.py"), "content": "x"}, project.rc)
+    assert denied.startswith("Error: write access denied")
+    assert not (project.root / "evil.py").exists()
+
+    assert agent_tools.write_file({"file_path": "pkg/new.py", "content": "print(1)\n"}, project.rc).startswith("Wrote")
+    assert (project.build / "pkg" / "new.py").read_text() == "print(1)\n"
+    assert agent_tools.delete_file({"file_path": "pkg/new.py"}, project.rc).startswith("Deleted")
+    assert not (project.build / "pkg" / "new.py").exists()
+    assert project.rc.unit_tests_running_context.changed_files == {os.path.join("pkg", "new.py")}
+
+
+def test_grep_and_ls(project):
+    hits = agent_tools.grep({"pattern": "def sub"}, project.rc)
+    assert hits == "app.py:5:def sub(a, b):"
+    assert agent_tools.grep({"pattern": "nope"}, project.rc).startswith("No matches")
+    assert agent_tools.grep({"pattern": ""}, project.rc).startswith("Error")
+
+    assert agent_tools.ls_files({}, project.rc).splitlines()[1:] == ["app.py"]
+    assert agent_tools.ls_files({"pattern": "**/*.py"}, project.rc).endswith("app.py")
+
+
+def test_execute_calls_answers_every_call_and_captures_errors(project, monkeypatch):
+    def boom(_args, _rc):
+        raise RuntimeError("kaput")
+
+    monkeypatch.setitem(agent_tools.TOOLS, "boom", boom)
+    results = agent_tools.execute_calls(
+        [
+            {"id": "1", "name": "read_file", "args": {"file_path": "app.py", "limit": 1}},
+            {"id": "2", "name": "unknown_tool", "args": {}},
+            {"id": "3", "name": "boom"},
+        ],
+        project.rc,
+    )
+    assert [r["call_id"] for r in results] == ["1", "2", "3"]
+    assert results[0]["output"].startswith("1: def add")
+    assert results[1]["output"] == "Error: unknown tool 'unknown_tool'."
+    assert results[2]["output"] == "Error: tool 'boom' failed: RuntimeError: kaput"
+
+
+def test_run_unit_tests_reports_pass_and_failure(project, monkeypatch):
+    log = project.root.parent / "log.txt"
+    log.write_text("FAILED test_x\nCaused by: boom\n")
+    outcomes = iter([(0, "", "/tmp/pass.txt"), (1, "FAILED test_x", str(log))])
+    monkeypatch.setattr(agent_tools.render_utils, "execute_script", lambda *a, **k: next(outcomes))
+    project.rc.unittests_script = "run_tests.sh"
+    context = project.rc.unit_tests_running_context
+
+    assert agent_tools.run_unit_tests({}, project.rc) == {"output": "All unit tests passed."}
+    assert context.verified_passing and context.verified_passing_log_path == "/tmp/pass.txt"
+
+    failure = agent_tools.run_unit_tests({}, project.rc)
+    assert failure["output"].startswith(f"Unit tests failed (exit code 1). Full log: {log}")
+    # raw output goes to the server for condensing, not truncated here
+    assert failure["test_output"] == "FAILED test_x"
+    # the full log is outside the build folder but greppable
+    assert agent_tools.grep({"pattern": "Caused by", "file_path": str(log)}, project.rc).endswith("Caused by: boom")
+
+
+def test_file_change_invalidates_verified_pass_and_read_cache(project):
+    context = project.rc.unit_tests_running_context
+    context.verified_passing = True
+    first = agent_tools.execute_calls([{"id": "1", "name": "read_file", "args": {"file_path": "app.py"}}], project.rc)
+    repeat = agent_tools.execute_calls([{"id": "2", "name": "read_file", "args": {"file_path": "app.py"}}], project.rc)
+    assert first[0]["output"].startswith("1: def add")
+    assert repeat[0]["output"].startswith("Same call as an earlier one")
+
+    agent_tools.write_file({"file_path": "other.py", "content": "y = 1\n"}, project.rc)
+    assert context.verified_passing is False
+    again = agent_tools.execute_calls([{"id": "3", "name": "read_file", "args": {"file_path": "app.py"}}], project.rc)
+    assert again[0]["output"].startswith("1: def add")
+
+
+def test_edit_file_returns_the_edited_region(project):
+    out = agent_tools.edit_file(
+        {
+            "file_path": "app.py",
+            "search": "def sub(a, b):\n    return a - b",
+            "replace": "def sub(a, b):\n    return b",
+        },
+        project.rc,
+    )
+    assert out.startswith("Edited") and "5: def sub(a, b):\n6:     return b" in out
+    assert "2:     return a - b" in out and "1: def add" not in out
+
+
+def test_grep_context_lines_and_include(project):
+    (project.build / "notes.txt").write_text("def sub is documented here\n")
+    hits = agent_tools.grep({"pattern": "def sub", "context_lines": 1, "include": "*.py"}, project.rc)
+    assert "notes.txt" not in hits
+    assert "app.py-4-" in hits and "app.py:5:def sub(a, b):" in hits and "app.py-6-" in hits
+
+
+def test_bound_truncates_long_lines_and_large_output():
+    bounded = agent_tools._bound("a" * (agent_tools.MAX_LINE_CHARS + 5) + "\n" + "b\n" * 40_000)
+    assert "[line truncated]" in bounded and "[truncated" in bounded
+    assert len(bounded) < agent_tools.MAX_OUTPUT_CHARS + 200