ayder-cli 2.2.7__tar.gz → 2.2.8__tar.gz

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ayder-cli
-Version: 2.2.7
+Version: 2.2.8
 Summary: AI agent for any LLMs
 Project-URL: Homepage, https://github.com/ayder/ayder-cli
 Project-URL: Repository, https://github.com/ayder/ayder-cli.git

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/docs/config.toml.example

@@ -48,11 +48,12 @@
 #      `export OLLAMA_API_KEY="<key>"`. The api_key config field is INERT on the
 #      native path, so a missing env var ⇒ 401 Unauthorized.
 #
-# NOTE on `think`: on the native `ollama` driver, ayder hardcodes thinking ON
-#       (think=True) and does NOT forward the configured level — so a
-#       `think = "high"` below documents intent, but the "low/medium/high"
-#       granularity is not applied. The `openai` driver sends no reasoning-effort
-#       parameter at all.
+# NOTE on `think`: on the native `ollama` driver, ayder defaults thinking ON
+#       (think = true) and forwards either a boolean or Ollama's "low",
+#       "medium", "high" levels. If a selected model rejects thinking mode,
+#       ayder retries that request once with think=false. Set `think = false`
+#       in an [llm.*] profile for known non-thinking models. The `openai`
+#       driver sends no reasoning-effort parameter at all.
 #
 # NOTE on tuning knobs — which actually take effect depends on the DRIVER. These
 #       agents run on the native `ollama` driver, which ignores most of them:
@@ -60,17 +61,16 @@
 #         • max_output_tokens — NOT sent on the ollama path (Ollama sizes
 #                               generation itself); honored only by the
 #                               openai-family drivers as max_tokens. Default 4096.
-#         • think             — hardcoded ON for ollama (level ignored); openai
-#                               sends none.
+#         • think             — sent on the ollama path (default true; accepts
+#                               false or "low"/"medium"/"high"); openai sends
+#                               none.
 #         • num_ctx           — on ollama it is provisional only (the real window
 #                               is auto-detected from /api/show); on the openai
 #                               path it sizes the context-manager budget.
 #                               Default 65536.
-#       The per-agent temperature / max_output_tokens / think values below are
-#       therefore largely INERT on this Ollama pipeline — they are kept to
-#       document intent and to carry over if you switch an agent to an `openai`
-#       profile. To actually tune these, use the `openai` driver — see
-#       [llm.openai] below.
+#       The per-agent temperature / max_output_tokens values below are largely
+#       INERT on this Ollama pipeline; per-agent `think` is applied when the
+#       agent uses the native ollama driver.
 # =============================================================================
 
 config_version = "2.0"
@@ -154,6 +154,7 @@ driver = "ollama"
 base_url = "http://localhost:11434"  # route :cloud models through the LOCAL daemon (auth via ~/.ollama/id_ed25519, one-time `ollama signin`)
 model = "deepseek-v4-pro:cloud"    # orchestrator default; per-agent `model` overrides this
 num_ctx = 131072
+think = true                       # default; set false for known non-thinking models
 # To hit ollama.com directly instead, swap the line above for:
 #   base_url = "https://ollama.com"   # no /v1; then `export OLLAMA_API_KEY=<key>` (the api_key field is inert on this path)
 
@@ -162,6 +163,7 @@ driver = "ollama"
 base_url = "http://localhost:11434"
 model = "qwen3.6:35b-a3b-coding-nvfp4"
 num_ctx = 32768                     # keep modest: local VRAM is the constraint
+think = true                        # default; set false if the selected model rejects thinking
 
 # Budget/throughput alternative — swap any cloud agent's `provider` to this, or
 # point a duplicate reviewer at it for cheap parallel passes.

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ayder-cli"
-version = "2.2.7"
+version = "2.2.8"
 description = "AI agent for any LLMs"
 readme = "README.md"
 requires-python = ">=3.12"

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/src/ayder_cli/core/config.py

@@ -2,7 +2,7 @@ import logging
 import tomllib
 from pathlib import Path
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
-from typing import Any, Callable, Dict
+from typing import Any, Callable, Dict, Literal
 
 logger = logging.getLogger(__name__)
 
@@ -319,6 +319,10 @@ class Config(BaseModel):
     max_history_messages: int = Field(default=0)
     prompt: str = Field(default="STANDARD")
     chat_protocol: str = Field(default="ollama")
+    # Ollama thinking mode. Defaults on because most local models in the
+    # primary path support it; set ``think = false`` in an [llm.*] profile for
+    # models that do not. Ollama also accepts "low", "medium", and "high".
+    think: bool | Literal["low", "medium", "high"] | None = Field(default=True)
     stop_sequences: list[str] = Field(default_factory=list)
     tool_tags: list[str] = Field(default_factory=lambda: ["core", "metadata"])
     temporal: TemporalConfig = Field(default_factory=TemporalConfig)
@@ -459,6 +463,25 @@ class Config(BaseModel):
             raise ValueError("max_history_messages must be non-negative (0 = unlimited)")
         return v
 
+    @field_validator("think", mode="before")
+    @classmethod
+    def validate_think(cls, v: Any) -> bool | Literal["low", "medium", "high"] | None:
+        if v is None or isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            normalized = v.strip().lower()
+            if normalized in {"true", "yes", "on", "1"}:
+                return True
+            if normalized in {"false", "no", "off", "0"}:
+                return False
+            if normalized == "low":
+                return "low"
+            if normalized == "medium":
+                return "medium"
+            if normalized == "high":
+                return "high"
+        raise ValueError("think must be true, false, low, medium, high, or null")
+
     @field_validator("agent_timeout")
     @classmethod
     def validate_agent_timeout(cls, v: int) -> int:

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/src/ayder_cli/providers/impl/ollama.py

@@ -1,7 +1,7 @@
 """Ollama provider routed through per-family chat drivers."""
 
 import json
-from typing import Any, AsyncGenerator, Dict, List, Optional
+from typing import Any, AsyncGenerator, Dict, List, Literal, Optional
 
 from loguru import logger
 from ollama import AsyncClient
@@ -19,6 +19,8 @@ from ayder_cli.providers.impl.ollama_drivers.base import ChatDriver, DriverMode
 from ayder_cli.providers.impl.ollama_drivers.registry import DriverRegistry
 from ayder_cli.providers.impl.ollama_inspector import OllamaInspector
 
+ThinkOption = bool | Literal["low", "medium", "high"] | None
+
 
 class OllamaProvider(AIProvider):
     """Native wire-protocol provider for local Ollama models.
@@ -116,6 +118,50 @@ class OllamaProvider(AIProvider):
             ):
                 yield chunk
 
+    def _configured_think(self) -> ThinkOption:
+        """Return the configured Ollama think option.
+
+        ``Config`` defaults this to True. Tests often pass loose mocks without a
+        real ``think`` field; those should behave like the real default.
+        """
+        value = getattr(self.config, "think", True)
+        if value is None or isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in {"true", "yes", "on", "1"}:
+                return True
+            if normalized in {"false", "no", "off", "0"}:
+                return False
+            if normalized == "low":
+                return "low"
+            if normalized == "medium":
+                return "medium"
+            if normalized == "high":
+                return "high"
+        return True
+
+    @staticmethod
+    def _is_unsupported_thinking_error(exc: BaseException) -> bool:
+        """Return True when Ollama rejected the requested thinking mode."""
+        message = str(exc).lower()
+        if "think" not in message and "thinking" not in message:
+            return False
+        return any(
+            marker in message
+            for marker in (
+                "not support",
+                "unsupported",
+                "invalid",
+                "unknown field",
+                "unrecognized",
+            )
+        )
+
+    @staticmethod
+    def _chunk_committed(chunk: NormalizedStreamChunk) -> bool:
+        return bool(chunk.content or chunk.reasoning or chunk.tool_calls)
+
     async def _stream_with_driver(
         self,
         driver: ChatDriver,
@@ -145,6 +191,34 @@ class OllamaProvider(AIProvider):
         model: str,
         tools: list[dict[str, Any]] | None,
         options: dict[str, Any] | None,
+    ) -> AsyncGenerator[NormalizedStreamChunk, None]:
+        think = self._configured_think()
+        committed = False
+        try:
+            async for chunk in self._stream_native_once(
+                messages, model, tools, options, think
+            ):
+                if self._chunk_committed(chunk):
+                    committed = True
+                yield chunk
+        except BaseException as exc:
+            if committed or think is False or not self._is_unsupported_thinking_error(exc):
+                raise
+            logger.info(
+                f"Ollama model {model!r} rejected think={think!r}; retrying with think=False"
+            )
+            async for chunk in self._stream_native_once(
+                messages, model, tools, options, False
+            ):
+                yield chunk
+
+    async def _stream_native_once(
+        self,
+        messages: list[dict[str, Any]],
+        model: str,
+        tools: list[dict[str, Any]] | None,
+        options: dict[str, Any] | None,
+        think: ThinkOption,
     ) -> AsyncGenerator[NormalizedStreamChunk, None]:
         # Let Ollama size the context window from the model itself (recent
         # versions do this automatically); do not force num_ctx.
@@ -156,7 +230,7 @@ class OllamaProvider(AIProvider):
             messages=ollama_messages,
             tools=ollama_tools,
             keep_alive=-1,
-            think=True,
+            think=think,
             stream=True,
         )
 
@@ -202,6 +276,35 @@ class OllamaProvider(AIProvider):
         model: str,
         tools: list[dict[str, Any]] | None,
         options: dict[str, Any] | None,
+    ) -> AsyncGenerator[NormalizedStreamChunk, None]:
+        think = self._configured_think()
+        committed = False
+        try:
+            async for chunk in self._stream_in_content_once(
+                driver, messages, model, tools, options, think
+            ):
+                if self._chunk_committed(chunk):
+                    committed = True
+                yield chunk
+        except BaseException as exc:
+            if committed or think is False or not self._is_unsupported_thinking_error(exc):
+                raise
+            logger.info(
+                f"Ollama model {model!r} rejected think={think!r}; retrying with think=False"
+            )
+            async for chunk in self._stream_in_content_once(
+                driver, messages, model, tools, options, False
+            ):
+                yield chunk
+
+    async def _stream_in_content_once(
+        self,
+        driver: ChatDriver,
+        messages: list[dict[str, Any]],
+        model: str,
+        tools: list[dict[str, Any]] | None,
+        options: dict[str, Any] | None,
+        think: ThinkOption,
     ) -> AsyncGenerator[NormalizedStreamChunk, None]:
         # Let Ollama size the context window from the model itself; do not
         # force num_ctx.
@@ -213,7 +316,7 @@ class OllamaProvider(AIProvider):
             messages=ollama_messages,
             tools=None,
             keep_alive=-1,
-            think=True,
+            think=think,
             stream=True,
         )
 

ayder_cli-2.2.8/src/ayder_cli/tui/rendering.py

@@ -0,0 +1,12 @@
+"""Safe render helpers for Textual widgets."""
+
+from textual.content import Content
+from textual.markup import MarkupError
+
+
+def markup_or_plain(content: str) -> Content:
+    """Render Textual markup, falling back to literal text if it is malformed."""
+    try:
+        return Content.from_markup(content)
+    except MarkupError:
+        return Content(content)

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/src/ayder_cli/tui/widgets.py

@@ -6,16 +6,17 @@ from typing import Any
 
 from textual.app import ComposeResult
 from textual.containers import Horizontal, VerticalScroll, Container
-from textual.widgets import Static, Input, Label, TextArea
-from textual.reactive import reactive
 from textual.message import Message
+from textual.reactive import reactive
 from textual.suggester import SuggestFromList
+from textual.widgets import Static, Input, Label, TextArea
 from rich.text import Text
 from rich.markdown import Markdown
 from rich.spinner import Spinner
 from rich.style import Style
 
 from ayder_cli.parser import content_processor
+from ayder_cli.tui.rendering import markup_or_plain
 from ayder_cli.tui.types import MessageType
 
 
@@ -337,11 +338,12 @@ class ThinkingPanel(Container):
         self._buffer += text
 
         content = self._buffer.strip()
+        renderable = markup_or_plain(content)
         if self._widget is None:
-            self._widget = Static(content, classes="thinking-content")
+            self._widget = Static(renderable, classes="thinking-content")
             self.mount(self._widget)
         else:
-            self._widget.update(content)
+            self._widget.update(renderable)
         self.scroll_end(animate=False)
 
     def clear(self) -> None:
@@ -720,14 +722,14 @@ class _SubmitTextArea(TextArea):
             return
         if not self._file_picker_suggestions:
             self._file_picker_widget.display = False
-            self._file_picker_widget.update("")
+            self._file_picker_widget.update(markup_or_plain(""))
             return
 
         lines = []
         for idx, suggestion in enumerate(self._file_picker_suggestions):
             marker = ">" if idx == self._file_picker_index else " "
             lines.append(f"{marker} @{suggestion}")
-        self._file_picker_widget.update("\n".join(lines))
+        self._file_picker_widget.update(markup_or_plain("\n".join(lines)))
         self._file_picker_widget.display = True
 
     def _close_file_picker(self) -> None:
@@ -1108,8 +1110,8 @@ class StatusBar(Horizontal):
 
     def compose(self) -> ComposeResult:
         mode_str = "".join(sorted(self._permissions))
-        yield Label(f"model: {self.model}", id="model-label")
-        yield Label(f" | mode: {mode_str}", id="mode-label")
+        yield Label(markup_or_plain(f"model: {self.model}"), id="model-label")
+        yield Label(markup_or_plain(f" | mode: {mode_str}"), id="mode-label")
         yield Label(" | ctx: —", id="token-label")
         yield Label(" | files: 0", id="files-label")
         yield Label("", id="skill-label")
@@ -1126,7 +1128,7 @@ class StatusBar(Horizontal):
         """Update the displayed model."""
         self.model = model
         label = self.query_one("#model-label", Label)
-        label.update(f"model: {model}")
+        label.update(markup_or_plain(f"model: {model}"))
 
     def update_context_usage(self, used: int, total: int) -> None:
         """Update the live context-window usage: current tokens / window size.
@@ -1151,12 +1153,12 @@ class StatusBar(Horizontal):
         self._permissions = permissions
         mode_str = "".join(sorted(permissions))
         label = self.query_one("#mode-label", Label)
-        label.update(f" | mode: {mode_str}")
+        label.update(markup_or_plain(f" | mode: {mode_str}"))
 
     def set_skill(self, skill_name: str | None) -> None:
         """Update the active skill label."""
         label = self.query_one("#skill-label", Label)
-        label.update(f" | skill: {skill_name}" if skill_name else "")
+        label.update(markup_or_plain(f" | skill: {skill_name}" if skill_name else ""))
 
     @staticmethod
     def _render_badges(

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/tests/core/test_config_v2.py

@@ -160,6 +160,39 @@ def test_max_concurrent_agents_range_validator():
             Config(max_concurrent_agents=bad)
 
 
+def test_think_defaults_true():
+    assert Config().think is True
+
+
+def test_think_accepts_false_and_levels():
+    assert Config(think=False).think is False
+    assert Config(think="false").think is False
+    assert Config(think="low").think == "low"
+    assert Config(think="medium").think == "medium"
+    assert Config(think="high").think == "high"
+
+
+def test_think_rejects_invalid_value():
+    with pytest.raises(ValueError):
+        Config(think="extreme")
+
+
+def test_think_can_be_set_in_llm_profile():
+    cfg = Config(
+        **{
+            "app": {"provider": "ollama_local"},
+            "llm": {
+                "ollama_local": {
+                    "driver": "ollama",
+                    "model": "gemma:latest",
+                    "think": False,
+                }
+            },
+        }
+    )
+    assert cfg.think is False
+
+
 def test_provider_profile_infers_driver():
     # A [llm.<name>] profile with no explicit driver infers via _DRIVER_BY_PROVIDER.
     cfg = Config(**{"app": {"provider": "qwen"},

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/tests/providers/ollama_drivers/test_provider_integration.py

@@ -2,6 +2,7 @@
 
 from unittest.mock import AsyncMock, MagicMock, patch
 
+from ollama import ResponseError
 import pytest
 
 from ayder_cli.providers.impl.ollama import OllamaProvider
@@ -70,6 +71,7 @@ async def test_provider_routes_through_drivers():
             pass
 
     assert captured_kwargs.get("tools") is not None
+    assert captured_kwargs.get("think") is True
     instance.show.assert_awaited_once_with("llama3.1:8b")
 
 
@@ -104,6 +106,7 @@ async def test_chat_protocol_xml_forces_generic_xml_driver():
             pass
 
     assert captured_kwargs.get("tools") is None
+    assert captured_kwargs.get("think") is True
     system_message = next(
         message for message in captured_kwargs["messages"] if message["role"] == "system"
     )
@@ -111,6 +114,112 @@ async def test_chat_protocol_xml_forces_generic_xml_driver():
     instance.show.assert_not_awaited()
 
 
+@pytest.mark.asyncio
+async def test_provider_sends_configured_think_false():
+    cfg = _config("llama3.1:8b")
+    cfg.think = False
+    captured_kwargs: dict = {}
+
+    async def fake_stream():
+        yield _mock_chunk(content="ok", done=True)
+
+    async def fake_chat(*args, **kwargs):
+        captured_kwargs.update(kwargs)
+        return fake_stream()
+
+    fake_show = MagicMock(
+        modelinfo={"llama.context_length": 32768},
+        capabilities=["tools"],
+        details=MagicMock(family="llama", quantization_level="Q4_K_M"),
+    )
+
+    with (
+        patch("ayder_cli.providers.impl.ollama.AsyncClient") as mock_client,
+        patch("ayder_cli.providers.impl.ollama_inspector.AsyncClient") as mock_inspector,
+    ):
+        instance = AsyncMock()
+        instance.chat.side_effect = fake_chat
+        instance.show = AsyncMock(return_value=fake_show)
+        mock_client.return_value = instance
+        mock_inspector.return_value = instance
+
+        provider = OllamaProvider(cfg)
+        async for _ in provider.stream_with_tools(
+            messages=[{"role": "user", "content": "hi"}],
+            model="llama3.1:8b",
+            tools=[{"type": "function", "function": {"name": "read_file"}}],
+        ):
+            pass
+
+    assert captured_kwargs.get("think") is False
+
+
+@pytest.mark.asyncio
+async def test_native_retries_with_think_false_when_model_rejects_thinking():
+    cfg = _config("llama3.1:8b")
+    cfg.think = True
+    calls: list[bool | str | None] = []
+
+    async def fake_stream():
+        yield _mock_chunk(content="ok", done=True)
+
+    async def fake_chat(*args, **kwargs):
+        calls.append(kwargs.get("think"))
+        if len(calls) == 1:
+            raise ResponseError("thinking is not supported by this model")
+        return fake_stream()
+
+    with patch("ayder_cli.providers.impl.ollama.AsyncClient") as mock_client:
+        instance = AsyncMock()
+        instance.chat.side_effect = fake_chat
+        mock_client.return_value = instance
+
+        provider = OllamaProvider(cfg)
+        results = [
+            chunk
+            async for chunk in provider._stream_native(
+                messages=[{"role": "user", "content": "hi"}],
+                model="llama3.1:8b",
+                tools=None,
+                options=None,
+            )
+        ]
+
+    assert calls == [True, False]
+    assert results[0].content == "ok"
+
+
+@pytest.mark.asyncio
+async def test_native_does_not_retry_thinking_error_after_committed_output():
+    cfg = _config("llama3.1:8b")
+    calls: list[bool | str | None] = []
+
+    async def failing_stream():
+        yield _mock_chunk(content="partial")
+        raise ResponseError("thinking is not supported by this model")
+
+    async def fake_chat(*args, **kwargs):
+        calls.append(kwargs.get("think"))
+        return failing_stream()
+
+    with patch("ayder_cli.providers.impl.ollama.AsyncClient") as mock_client:
+        instance = AsyncMock()
+        instance.chat.side_effect = fake_chat
+        mock_client.return_value = instance
+
+        provider = OllamaProvider(cfg)
+        with pytest.raises(ResponseError):
+            async for _ in provider._stream_native(
+                messages=[{"role": "user", "content": "hi"}],
+                model="llama3.1:8b",
+                tools=None,
+                options=None,
+            ):
+                pass
+
+    assert calls == [True]
+
+
 @pytest.mark.asyncio
 async def test_driver_resolution_is_cached_across_turns():
     cfg = _config("llama3.1:8b")

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/tests/tui/test_status_bar_badges.py

@@ -15,6 +15,14 @@ def test_compose_yields_plugin_badges_label():
     assert "plugin-badges" in ids
 
 
+def test_model_label_malformed_markup_falls_back_to_plain_text():
+    malformed = '[agent-result name="reviewer" run="3" status="completed"]'
+    bar = StatusBar(model=malformed)
+    labels = {getattr(w, "id", None): w for w in bar.compose()}
+
+    assert labels["model-label"].render().plain == f"model: {malformed}"
+
+
 def test_render_badges_empty_is_blank():
     rendered = StatusBar._render_badges({})
     assert rendered.plain == ""

{ayder_cli-2.2.7 → ayder_cli-2.2.8}/tests/tui/test_widgets.py

@@ -2,7 +2,11 @@
 
 from unittest.mock import patch, MagicMock
 
-from ayder_cli.tui.widgets import ActivityBar, AgentPanel, ThinkingPanel
+from textual.content import Content
+from textual.markup import MarkupError
+from textual.widgets import Static
+
+from ayder_cli.tui.widgets import ActivityBar, AgentPanel, ThinkingPanel, _SubmitTextArea
 
 
 class TestActivityBarAgents:
@@ -82,6 +86,41 @@ class TestThinkingPanelStreaming:
         assert panel._widget is None
         mock_mount.assert_not_called()
 
+    @patch.object(ThinkingPanel, "scroll_end")
+    @patch.object(ThinkingPanel, "mount")
+    def test_malformed_markup_falls_back_to_plain_text(self, mock_mount, _mock_scroll):
+        panel = ThinkingPanel()
+        content = '[agent-result name="reviewer" run="3" status="completed"]'
+
+        try:
+            Content.from_markup(content)
+        except MarkupError:
+            pass
+        else:
+            raise AssertionError("test fixture should be malformed Textual markup")
+
+        panel.add_thinking(content)
+
+        assert panel._widget is not None
+        assert panel._widget.render().plain == content
+        mock_mount.assert_called_once()
+
+    @patch.object(ThinkingPanel, "scroll_end")
+    @patch.object(ThinkingPanel, "mount")
+    def test_streamed_malformed_markup_update_falls_back_to_plain_text(
+        self, mock_mount, _mock_scroll
+    ):
+        panel = ThinkingPanel()
+        malformed = '[calls call_agent: name="code-reviewer", task="Review src/auth.py"]'
+        expected = f"safe prefix {malformed}"
+
+        panel.add_thinking("safe prefix ")
+        panel.add_thinking(malformed)
+
+        assert panel._widget is not None
+        assert panel._widget.render().plain == expected
+        mock_mount.assert_called_once()
+
     @patch.object(ThinkingPanel, "scroll_end")
     @patch.object(ThinkingPanel, "mount")
     def test_start_phase_inserts_separator_between_phases(self, mock_mount, _mock_scroll):
@@ -111,6 +150,18 @@ class TestThinkingPanelStreaming:
         assert panel._needs_separator is False
 
 
+class TestFilePickerRendering:
+    def test_malformed_markup_path_falls_back_to_plain_text(self):
+        input_widget = _SubmitTextArea()
+        input_widget._file_picker_widget = Static("", id="file-picker")
+        malformed = '[agent-result name="reviewer" run="3" status="completed"]'
+        input_widget._file_picker_suggestions = [malformed]
+
+        input_widget._render_file_picker()
+
+        assert input_widget._file_picker_widget.render().plain == f"> @{malformed}"
+
+
 class TestAgentPanelDataModel:
     @patch.object(AgentPanel, "mount")
     def test_add_agent_creates_entry(self, mock_mount):