deepagents-code 0.1.28__tar.gz → 0.1.29__tar.gz

{deepagents_code-0.1.28 → deepagents_code-0.1.29}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.29](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.28...deepagents-code==0.1.29) (2026-07-01)
+
+### Features
+
+* Add rubric iteration controls ([#4405](https://github.com/langchain-ai/deepagents/issues/4405)) ([d6692a7](https://github.com/langchain-ai/deepagents/commit/d6692a7c713490f170b17510d613e02ee37574ab))
+* Add Claude Sonnet 5 to model picker ([#4386](https://github.com/langchain-ai/deepagents/issues/4386)) ([64758dd](https://github.com/langchain-ai/deepagents/commit/64758dddf8b46c5b68c345fb1eac1fb7bcbf7f7e))
+
+### Bug Fixes
+
+* Full-width chat messages, hide scrollbar, flush input bg ([#4374](https://github.com/langchain-ai/deepagents/issues/4374)) ([1f8e8dc](https://github.com/langchain-ai/deepagents/commit/1f8e8dc942ac54c4014ac48f9345ee0201be0b1b))
+* Resolve editable SDK version metadata ([#4394](https://github.com/langchain-ai/deepagents/issues/4394)) ([3239bf4](https://github.com/langchain-ai/deepagents/commit/3239bf4edf2be3037bb18315463ac6a0c3537e5c))
+* Unblock MCP force reconnect modal ([#4396](https://github.com/langchain-ai/deepagents/issues/4396)) ([8b7eab0](https://github.com/langchain-ai/deepagents/commit/8b7eab023db686f577d16f4f9ac872205baf136f))
+
 ## [0.1.28](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.27...deepagents-code==0.1.28) (2026-06-29)
 
 ### Features

{deepagents_code-0.1.28 → deepagents_code-0.1.29}/COMMANDS.md

@@ -8,7 +8,7 @@ Regenerate this file with `make commands-catalog` after changing command names,
 aliases, descriptions, visibility, or hidden-command metadata.
 
 
-## Public (30)
+## Public (31)
 
 | Command | Aliases | Description |
 | --- | --- | --- |
@@ -34,6 +34,7 @@ aliases, descriptions, visibility, or hidden-command metadata.
 | `/remember` |  | Save useful context to memory or skills |
 | `/restart` |  | Restart the agent server |
 | `/rubric` | `/criteria` | Set explicit acceptance criteria for rubric grading |
+| `/scrollbar` |  | Show or hide the chat scrollbar |
 | `/skill-creator` |  | Create or refine agent skills |
 | `/theme` |  | Change color theme |
 | `/threads` |  | Browse and resume past threads |

{deepagents_code-0.1.28 → deepagents_code-0.1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-code
-Version: 0.1.28
+Version: 0.1.29
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
@@ -27,7 +27,7 @@ Classifier: Topic :: Terminals
 Requires-Python: <4.0,>=3.11
 Requires-Dist: aiosqlite<1.0.0,>=0.22.1
 Requires-Dist: deepagents-acp<1.0.0,>=0.0.8
-Requires-Dist: deepagents==0.7.0a2
+Requires-Dist: deepagents==0.7.0a3
 Requires-Dist: httpx<1.0.0,>=0.28.1
 Requires-Dist: langchain-anthropic<2.0.0,>=1.4.7
 Requires-Dist: langchain-google-genai<5.0.0,>=4.2.6

{deepagents_code-0.1.28 → deepagents_code-0.1.29}/deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "14a0fb1"
+BUILD_COMMIT = "c540098"

{deepagents_code-0.1.28 → deepagents_code-0.1.29}/deepagents_code/_env_vars.py

@@ -206,6 +206,18 @@ Defaults to enabled; set to a falsy value (`0`, `false`, `no`, `off`, or empty)
 to hide replica tracing details from the splash while leaving tracing active.
 """
 
+SHOW_SCROLLBAR = "DEEPAGENTS_CODE_SHOW_SCROLLBAR"
+"""Show the vertical scrollbar in the chat area when enabled.
+
+Off by default; use the `/scrollbar` slash command or `[ui].show_scrollbar` in
+config.toml to toggle. Parsed by `classify_env_bool` (an unrecognized or empty
+value falls through to the config value rather than forcing the default).
+
+When set, this env var takes precedence over the persisted `[ui].show_scrollbar`
+config value on launch, so a `/scrollbar` toggle will not appear to "stick"
+across restarts while the env var remains set.
+"""
+
 THEME = "DEEPAGENTS_CODE_THEME"
 """Force the CLI to launch with this theme name when set."""
 

{deepagents_code-0.1.28 → deepagents_code-0.1.29}/deepagents_code/_server_config.py

@@ -80,7 +80,7 @@ def _read_env_str(suffix: str) -> str | None:
     return os.environ.get(f"{SERVER_ENV_PREFIX}{suffix}")
 
 
-def _read_env_int(suffix: str, *, default: int) -> int:
+def _read_env_int(suffix: str, *, default: int | None) -> int | None:
     """Read a `DEEPAGENTS_CODE_SERVER_*` integer from the environment.
 
     Args:
@@ -88,7 +88,7 @@ def _read_env_int(suffix: str, *, default: int) -> int:
         default: Value when the variable is absent or malformed.
 
     Returns:
-        Parsed integer, or the default when parsing fails.
+        Parsed integer, or the default when absent or parsing fails.
     """
     raw = os.environ.get(f"{SERVER_ENV_PREFIX}{suffix}")
     if raw is None:
@@ -264,9 +264,8 @@ class ServerConfig:
     `None` reuses the main agent model.
     """
 
-    rubric_max_iterations: int = 3
-    """Grader iterations per rubric attempt before the agent stops with
-    `'max_iterations_reached'`."""
+    rubric_max_iterations: int | None = None
+    """Explicit grader iterations per rubric attempt; `None` uses the SDK default."""
 
     sandbox_type: str | None = None
     """Sandbox backend identifier (e.g. `'daytona'`); `None` runs tools on the
@@ -304,13 +303,21 @@ class ServerConfig:
         """Normalize fields and validate invariants.
 
         Raises:
-            ValueError: If `shell_allow_list` is an empty list.
+            TypeError: If `rubric_max_iterations` is a boolean.
+            ValueError: If `shell_allow_list` is an empty list or
+                `rubric_max_iterations` is non-positive.
         """
         if self.sandbox_type == "none":
             object.__setattr__(self, "sandbox_type", None)
         if self.shell_allow_list is not None and len(self.shell_allow_list) == 0:
             msg = "shell_allow_list must be None or non-empty"
             raise ValueError(msg)
+        if isinstance(self.rubric_max_iterations, bool):
+            msg = "rubric_max_iterations must be None or a positive integer"
+            raise TypeError(msg)
+        if self.rubric_max_iterations is not None and self.rubric_max_iterations <= 0:
+            msg = "rubric_max_iterations must be None or a positive integer"
+            raise ValueError(msg)
 
     # ------------------------------------------------------------------
     # Serialization
@@ -356,7 +363,11 @@ class ServerConfig:
                 self.interpreter_ptc_acknowledge_unsafe
             ).lower(),
             "RUBRIC_MODEL": self.rubric_model,
-            "RUBRIC_MAX_ITERATIONS": str(self.rubric_max_iterations),
+            "RUBRIC_MAX_ITERATIONS": (
+                str(self.rubric_max_iterations)
+                if self.rubric_max_iterations is not None
+                else None
+            ),
             "SANDBOX_TYPE": self.sandbox_type,
             "SANDBOX_ID": self.sandbox_id,
             "SANDBOX_SNAPSHOT_NAME": self.sandbox_snapshot_name,
@@ -406,7 +417,7 @@ class ServerConfig:
                 "INTERPRETER_PTC_ACKNOWLEDGE_UNSAFE"
             ),
             rubric_model=_read_env_str("RUBRIC_MODEL") or None,
-            rubric_max_iterations=_read_env_int("RUBRIC_MAX_ITERATIONS", default=3),
+            rubric_max_iterations=_read_env_int("RUBRIC_MAX_ITERATIONS", default=None),
             sandbox_type=_read_env_str("SANDBOX_TYPE"),
             sandbox_id=_read_env_str("SANDBOX_ID"),
             sandbox_snapshot_name=_read_env_str("SANDBOX_SNAPSHOT_NAME") or None,
@@ -443,7 +454,7 @@ class ServerConfig:
         interpreter_ptc: str | list[str] | None = None,
         interpreter_ptc_acknowledge_unsafe: bool = False,
         rubric_model: str | None = None,
-        rubric_max_iterations: int = 3,
+        rubric_max_iterations: int | None = None,
         mcp_config_path: str | None,
         no_mcp: bool,
         trust_project_mcp: bool | None,
@@ -478,7 +489,8 @@ class ServerConfig:
             interpreter_ptc_acknowledge_unsafe: Mirror of
                 `settings.interpreter_ptc_acknowledge_unsafe`.
             rubric_model: Grader model spec; `None` reuses the main model.
-            rubric_max_iterations: Grader iterations per rubric attempt.
+            rubric_max_iterations: Explicit grader iterations per rubric attempt;
+                `None` uses the SDK default.
             mcp_config_path: Path to MCP config.
             no_mcp: Disable MCP.
             trust_project_mcp: Trust project MCP servers.

deepagents_code-0.1.29/deepagents_code/_testing_models.py

@@ -0,0 +1,317 @@
+"""Internal chat models used by local integration tests."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
+from langchain_core.messages import AIMessage, BaseMessage
+from langchain_core.outputs import ChatGeneration, ChatResult
+from pydantic import Field
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+    from langchain_core.callbacks import CallbackManagerForLLMRun
+    from langchain_core.language_models import LanguageModelInput
+    from langchain_core.runnables import Runnable
+    from langchain_core.tools import BaseTool
+
+
+# Prompt markers that drive `ToolCallingIntegrationChatModel`. Each marker is the
+# full token (including the trailing `=`); the file path follows on the same line,
+# e.g. `DCA_TEST_WRITE_FILE=/tmp/out.txt`. These are the single source of truth
+# shared with the integration tests, so the model and tests cannot drift apart.
+DCA_TEST_WRITE_FILE_MARKER = "DCA_TEST_WRITE_FILE="
+DCA_TEST_DELEGATE_WRITE_MARKER = "DCA_TEST_DELEGATE_WRITE="
+DCA_SUBAGENT_WRITE_FILE_MARKER = "DCA_SUBAGENT_WRITE_FILE="
+
+# Distinct file contents per write path, so a test asserting on file content can
+# prove which branch executed — in particular that subagent mode delegated through
+# the `task` tool rather than writing directly.
+TOP_LEVEL_WRITE_CONTENT = "auto-approved"
+SUBAGENT_WRITE_CONTENT = "auto-approved-subagent"
+
+
+class DeterministicIntegrationChatModel(GenericFakeChatModel):
+    """Deterministic chat model for integration tests.
+
+    This subclasses LangChain's `GenericFakeChatModel` so the implementation
+    stays aligned with the core fake-chat-model test surface, while overriding
+    generation to remain prompt-driven and restart-safe for real CLI server
+    integration tests.
+
+    Why the existing `langchain_core` fakes cannot be reused here:
+
+    1. Every core fake (`GenericFakeChatModel`, `FakeListChatModel`,
+        `FakeMessagesListChatModel`) pops from an iterator or cycles an index —
+        the actual prompt is ignored. App integration tests start and stop the
+        server process, which resets in-memory state. An iterator-based model
+        either raises `StopIteration` or replays from the beginning after a
+        restart, producing wrong or missing responses. This model derives output
+        solely from the prompt text, so identical input always produces
+        identical output regardless of process lifecycle.
+
+    2. The agent runtime calls `model.bind_tools(schemas)` during
+        initialization. None of the core fakes implement `bind_tools`, so they
+        raise `AttributeError` in any agent-loop context. This model provides a
+        no-op passthrough.
+
+    3. The app server reads `model.profile` for capability negotiation (e.g.
+        `tool_calling`, `max_input_tokens`). Core fakes have no such attribute,
+        causing `AttributeError` or silent misconfiguration at runtime.
+
+    Additionally, the compact middleware issues summarization prompts mid-
+    conversation. A list-based model cannot distinguish these from normal user
+    turns without pre-knowledge of exact call ordering, whereas this model
+    detects summary requests by inspecting the prompt content.
+    """
+
+    model: str = "fake"
+    # Required by `GenericFakeChatModel`, but our override does not consume it.
+    messages: object = Field(default_factory=lambda: iter(()))
+    profile: dict[str, Any] | None = Field(
+        default_factory=lambda: {
+            "tool_calling": True,
+            "max_input_tokens": 8000,
+        }
+    )
+
+    def bind_tools(
+        self,
+        tools: Sequence[dict[str, Any] | type | Callable | BaseTool],  # noqa: ARG002
+        *,
+        tool_choice: str | None = None,  # noqa: ARG002
+        **kwargs: Any,  # noqa: ARG002
+    ) -> Runnable[LanguageModelInput, AIMessage]:
+        """Return self so the agent can bind tool schemas during tests."""
+        return self
+
+    def _generate(
+        self,
+        messages: list[BaseMessage],
+        stop: list[str] | None = None,  # noqa: ARG002
+        run_manager: CallbackManagerForLLMRun | None = None,  # noqa: ARG002
+        **kwargs: Any,  # noqa: ARG002
+    ) -> ChatResult:
+        """Produce a deterministic reply derived from the prompt text.
+
+        Returns:
+            A single-message `ChatResult` with deterministic content.
+        """
+        prompt = "\n".join(
+            text
+            for message in messages
+            if (text := self._stringify_message(message)).strip()
+        )
+        if self._looks_like_summary_request(prompt):
+            content = "integration summary"
+        else:
+            excerpt = " ".join(prompt.split()[-18:])
+            if excerpt:
+                content = f"integration reply: {excerpt}"
+            else:
+                content = "integration reply"
+
+        return ChatResult(
+            generations=[ChatGeneration(message=AIMessage(content=content))]
+        )
+
+    @property
+    def _llm_type(self) -> str:
+        """LangChain model type identifier."""
+        return "deterministic-integration"
+
+    @staticmethod
+    def _stringify_message(message: BaseMessage) -> str:
+        """Flatten message content into plain text for deterministic responses.
+
+        Returns:
+            Plain-text content extracted from the message.
+        """
+        content = message.content
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts: list[str] = []
+            for block in content:
+                if isinstance(block, str):
+                    parts.append(block)
+                elif isinstance(block, dict) and block.get("type") == "text":
+                    text = block.get("text")
+                    if isinstance(text, str):
+                        parts.append(text)
+            return " ".join(parts)
+        return str(content)
+
+    @staticmethod
+    def _looks_like_summary_request(prompt: str) -> bool:
+        """Detect the middleware's summary-generation prompt.
+
+        Returns:
+            `True` when the prompt appears to be a summarization request.
+        """
+        lowered = prompt.lower()
+        return (
+            "messages to summarize" in lowered
+            or "condense the following conversation" in lowered
+            or "<summary>" in lowered
+        )
+
+
+def _extract_marker_path(prompt: str, marker: str) -> str:
+    """Extract the file path that follows a prompt marker on the same line.
+
+    Args:
+        prompt: The flattened prompt text.
+        marker: The marker token (including its trailing `=`) to locate.
+
+    Returns:
+        The stripped file path immediately following the marker.
+
+    Raises:
+        ValueError: If the marker is present but not followed by a path, so a
+            malformed test prompt fails loudly here instead of silently
+            degrading to a `"done"` reply or raising an opaque `IndexError`.
+    """
+    _, _, tail = prompt.partition(marker)
+    lines = tail.splitlines()
+    file_path = lines[0].strip() if lines else ""
+    if not file_path:
+        msg = (
+            f"Test model saw marker {marker!r} but found no file path after it; "
+            f"check the integration-test prompt construction."
+        )
+        raise ValueError(msg)
+    return file_path
+
+
+def _tool_call_result(name: str, args: dict[str, Any], call_id: str) -> ChatResult:
+    """Build a single-tool-call `ChatResult`.
+
+    Returns:
+        A `ChatResult` wrapping an `AIMessage` with exactly one tool call.
+    """
+    return ChatResult(
+        generations=[
+            ChatGeneration(
+                message=AIMessage(
+                    content="",
+                    tool_calls=[
+                        {
+                            "name": name,
+                            "args": args,
+                            "id": call_id,
+                            "type": "tool_call",
+                        }
+                    ],
+                )
+            )
+        ]
+    )
+
+
+class ToolCallingIntegrationChatModel(DeterministicIntegrationChatModel):
+    """Deterministic tool-calling model for auto-approve integration tests.
+
+    Generation is driven entirely by prompt markers (the module-level `DCA_*`
+    constants), so output is restart-safe and independent of call ordering — the
+    same rationale as the parent `DeterministicIntegrationChatModel`:
+
+    - `DCA_TEST_WRITE_FILE=<path>` emits a top-level `write_file` call.
+    - `DCA_TEST_DELEGATE_WRITE=<path>` emits a `task` call delegating to the
+      `general-purpose` subagent, whose prompt then carries
+      `DCA_SUBAGENT_WRITE_FILE=<path>` to trigger the subagent's `write_file`.
+    - `DCA_SUBAGENT_WRITE_FILE=<path>` emits the subagent's `write_file` call.
+
+    Each marker fires only on the agent's first turn (no prior `ToolMessage`),
+    so once the tool result returns the model replies with a plain `"done"` and
+    the agent loop terminates instead of re-issuing the tool call.
+    """
+
+    # Only `_generate` is overridden; the inherited `_stream` would bypass this
+    # marker dispatch entirely, so streaming must be disabled.
+    disable_streaming: bool = True
+
+    def _generate(
+        self,
+        messages: list[BaseMessage],
+        stop: list[str] | None = None,  # noqa: ARG002
+        run_manager: CallbackManagerForLLMRun | None = None,  # noqa: ARG002
+        **kwargs: Any,  # noqa: ARG002
+    ) -> ChatResult:
+        """Emit a deterministic tool call (or terminal reply) from prompt markers.
+
+        The `has_tool_result` guard ensures each marker fires only on the
+        agent's first turn; once a `ToolMessage` is present the model returns
+        `"done"` so the agent loop terminates.
+
+        A recognized marker with no file path raises `ValueError` (via
+        `_extract_marker_path`) rather than degrading to `"done"`.
+
+        Returns:
+            A single-message `ChatResult`: an `AIMessage` carrying a `task` or
+            `write_file` tool call when a marker matches and no tool result is
+            present yet, otherwise a plain `"done"` reply.
+        """
+        prompt = "\n".join(
+            text
+            for message in messages
+            if (text := self._stringify_message(message)).strip()
+        )
+        has_tool_result = any(message.type == "tool" for message in messages)
+        if not has_tool_result:
+            for marker, build_tool_call in self._marker_dispatch():
+                if marker in prompt:
+                    name, args, call_id = build_tool_call(
+                        _extract_marker_path(prompt, marker)
+                    )
+                    return _tool_call_result(name, args, call_id)
+
+        return ChatResult(
+            generations=[ChatGeneration(message=AIMessage(content="done"))]
+        )
+
+    @staticmethod
+    def _marker_dispatch() -> tuple[
+        tuple[str, Callable[[str], tuple[str, dict[str, Any], str]]], ...
+    ]:
+        """Return ordered `(marker, tool-call builder)` pairs.
+
+        The delegate marker is checked before the plain write markers because
+        its emitted `task` description embeds `DCA_SUBAGENT_WRITE_FILE=`; the
+        first marker found in the prompt wins.
+
+        Returns:
+            Marker-to-builder pairs in precedence order. Each builder maps an
+            extracted file path to a `(tool_name, args, call_id)` triple.
+        """
+        return (
+            (
+                DCA_TEST_DELEGATE_WRITE_MARKER,
+                lambda path: (
+                    "task",
+                    {
+                        "description": f"{DCA_SUBAGENT_WRITE_FILE_MARKER}{path}",
+                        "subagent_type": "general-purpose",
+                    },
+                    "call_task",
+                ),
+            ),
+            (
+                DCA_SUBAGENT_WRITE_FILE_MARKER,
+                lambda path: (
+                    "write_file",
+                    {"file_path": path, "content": SUBAGENT_WRITE_CONTENT},
+                    "call_write_file",
+                ),
+            ),
+            (
+                DCA_TEST_WRITE_FILE_MARKER,
+                lambda path: (
+                    "write_file",
+                    {"file_path": path, "content": TOP_LEVEL_WRITE_CONTENT},
+                    "call_write_file",
+                ),
+            ),
+        )

{deepagents_code-0.1.28 → deepagents_code-0.1.29}/deepagents_code/_version.py

@@ -2,7 +2,7 @@
 
 # Keep the `x-release-please-version` annotation — release-please uses it to
 # bump `__version__` in sync with `pyproject.toml` on every release PR.
-__version__ = "0.1.28"  # x-release-please-version
+__version__ = "0.1.29"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/code"
 """URL for `deepagents-code` documentation."""

{deepagents_code-0.1.28 → deepagents_code-0.1.29}/deepagents_code/agent.py

@@ -10,13 +10,19 @@ import shutil
 import tempfile
 import tomllib
 import warnings
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import TYPE_CHECKING, Any, cast
 
 from deepagents import create_deep_agent
 from deepagents.backends import CompositeBackend, LocalShellBackend
 from deepagents.backends.filesystem import FilesystemBackend
-from deepagents.middleware import MemoryMiddleware, RubricMiddleware, SkillsMiddleware
+from deepagents.middleware import (
+    GRADER_SYSTEM_PROMPT,
+    FilesystemMiddleware,
+    MemoryMiddleware,
+    RubricMiddleware,
+    SkillsMiddleware,
+)
 
 # Backwards-compat flag: SDKs before 0.5.4 accept only `list[str]` for
 # `SkillsMiddleware.sources`; newer SDKs expose the `SkillSource` alias
@@ -52,6 +58,10 @@ if TYPE_CHECKING:
     from deepagents_code.output import OutputFormat
 
 from langchain.agents.middleware.types import AgentMiddleware
+from langchain.tools import (
+    ToolRuntime,  # noqa: TC002  # LangChain inspects this annotation for runtime injection.
+)
+from langchain_core.tools import StructuredTool, tool
 
 from deepagents_code import theme
 from deepagents_code._cli_context import CLIContextSchema
@@ -90,6 +100,66 @@ logger = logging.getLogger(__name__)
 REQUIRE_COMPACT_TOOL_APPROVAL: bool = True
 """When `True`, `compact_conversation` requires HITL approval like other gated tools."""
 
+_RUBRIC_GRADER_READ_FILE_PREFIX = "/large_tool_results/"
+_RUBRIC_GRADER_SYSTEM_PROMPT = (
+    GRADER_SYSTEM_PROMPT
+    + "\n\nWhen the transcript says a tool result was saved under "
+    + f"`{_RUBRIC_GRADER_READ_FILE_PREFIX}`, use the `read_file` tool to inspect "
+    + "the referenced evidence before deciding that a criterion lacks support. "
+    + "Only read paths that are explicitly present in the transcript."
+)
+
+
+def _validate_rubric_grader_read_path(file_path: str) -> str | None:
+    normalized = file_path.replace("\\", "/")
+    if not normalized.startswith(_RUBRIC_GRADER_READ_FILE_PREFIX):
+        return "Rubric grader can only read files under /large_tool_results/."
+    parts = PurePosixPath(normalized).parts
+    if ".." in parts or "~" in parts:
+        return "Invalid path."
+    return None
+
+
+def _create_rubric_grader_tools(backend: CompositeBackend) -> list[BaseTool]:
+    filesystem = FilesystemMiddleware(backend=backend)
+    sdk_read_file: StructuredTool | None = None
+    for candidate in filesystem.tools:
+        if candidate.name == "read_file":
+            sdk_read_file = cast("StructuredTool", candidate)
+            break
+    if sdk_read_file is None:
+        msg = "SDK read_file tool is unavailable."
+        raise RuntimeError(msg)
+
+    sdk_read_file_func = sdk_read_file.func
+    if sdk_read_file_func is None:
+        msg = "SDK read_file tool is missing a sync implementation."
+        raise RuntimeError(msg)
+
+    @tool(description=sdk_read_file.description)
+    def read_file(
+        file_path: str,
+        runtime: ToolRuntime[None, Any],
+        offset: int = 0,
+        limit: int = 100,
+    ) -> object:
+        """Read an offloaded tool result referenced in the transcript.
+
+        Returns:
+            The SDK `read_file` tool result, or an error message when the path is
+            outside the grader evidence directory.
+        """
+        if error := _validate_rubric_grader_read_path(file_path):
+            return error
+        return sdk_read_file_func(
+            file_path=file_path,
+            runtime=runtime,
+            offset=offset,
+            limit=limit,
+        )
+
+    return [read_file]
+
 
 def _sanitize_agent_message_name(agent_name: str) -> str:
     """Return a provider-safe message name for a user-facing agent name.
@@ -275,17 +345,17 @@ def _resolve_ptc_option(
         return None
 
     live_names: list[str] = []
-    for tool in tools:
-        if isinstance(tool, _BaseTool):
-            name = tool.name
+    for candidate in tools:
+        if isinstance(candidate, _BaseTool):
+            name = candidate.name
             if isinstance(name, str):
                 live_names.append(name)
-        elif isinstance(tool, dict):
-            raw_name = cast("dict[str, Any]", tool).get("name")
+        elif isinstance(candidate, dict):
+            raw_name = cast("dict[str, Any]", candidate).get("name")
             if isinstance(raw_name, str):
                 live_names.append(raw_name)
         else:
-            attr = getattr(tool, "name", None)
+            attr = getattr(candidate, "name", None)
             if isinstance(attr, str):
                 live_names.append(attr)
     live_set: set[str] = set(live_names)
@@ -1251,7 +1321,7 @@ def create_cli_agent(
     enable_shell: bool = True,
     enable_interpreter: bool = False,
     rubric_model: str | BaseChatModel | None = None,
-    rubric_max_iterations: int = 3,
+    rubric_max_iterations: int | None = None,
     checkpointer: BaseCheckpointSaver | None = None,
     mcp_server_info: list[MCPServerInfo] | None = None,
     cwd: str | Path | None = None,
@@ -1333,8 +1403,9 @@ def create_cli_agent(
             A `'provider:model'` string or `BaseChatModel`.
 
             When `None`, the main `model` is reused.
-        rubric_max_iterations: Grader iterations per rubric attempt before the
-            agent terminates with `'max_iterations_reached'`.
+        rubric_max_iterations: Explicit grader iterations per rubric attempt
+            before the agent terminates with `'max_iterations_reached'`; `None`
+            uses the SDK default.
         checkpointer: Optional checkpointer for session persistence.
             When `None`, the graph is compiled without a checkpointer.
         mcp_server_info: MCP server metadata to surface in the system prompt.
@@ -1728,12 +1799,14 @@ def create_cli_agent(
             message="The middleware `RubricMiddleware` is in beta",
             category=Warning,
         )
-        agent_middleware.append(
-            RubricMiddleware(
-                model=rubric_model if rubric_model is not None else model,
-                max_iterations=rubric_max_iterations,
-            )
-        )
+        rubric_kwargs: dict[str, Any] = {
+            "model": rubric_model if rubric_model is not None else model,
+            "system_prompt": _RUBRIC_GRADER_SYSTEM_PROMPT,
+            "tools": _create_rubric_grader_tools(composite_backend),
+        }
+        if rubric_max_iterations is not None:
+            rubric_kwargs["max_iterations"] = rubric_max_iterations
+        agent_middleware.append(RubricMiddleware(**rubric_kwargs))
 
     # Create the agent
     all_subagents: list[SubAgent | CompiledSubAgent | AsyncSubAgent] = [