steerable-agent-runtime 0.4.0__tar.gz → 0.5.0__tar.gz

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.4.0
+Version: 0.5.0
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.4.0"
+version = "0.5.0"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 readme = "README.md"
 requires-python = ">=3.10"

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/src/steerable_agent_runtime/harness.py

@@ -371,6 +371,10 @@ class NullValidator:
 class SelfCritique:
     """The existing discipline-retry + grounding stack (AntiHallucinationHooks)."""
 
+    #: Headless fills this from the TB instruction. Empty leaves claimed /
+    #: eager-deferred blind (``detect_execution_intent_in_user_message``
+    #: is false on "") and the grounding judge sees no user question.
+    user_question: str = ""
     name: str = "self_critique"
     assumes: str = (
         "the model sometimes claims executions it did not perform; a "
@@ -380,9 +384,27 @@ class SelfCritique:
     def hooks(self, *, provider: LLMProvider | None = None) -> LoopHooks:
         if provider is None:
             raise ValueError("SelfCritique requires the turn's LLM provider")
-        from .antihallucination import AntiHallucinationHooks
+        from .antihallucination import (
+            AntiHallucinationConfig,
+            AntiHallucinationHooks,
+            detect_execution_intent_in_user_message,
+        )
 
-        return _BeforeCompletionOnly(AntiHallucinationHooks(provider))
+        question = self.user_question
+        # Desktop exec-intent is chat ("跑一下" / "execute"). TB instructions
+        # are unattended execution even when they never say "run".
+        if question and not detect_execution_intent_in_user_message(question):
+            question = f"Execute the following.\n{question}"
+        return _BeforeCompletionOnly(
+            AntiHallucinationHooks(
+                provider,
+                AntiHallucinationConfig(
+                    user_question=question,
+                    tools_available=True,
+                    enable_routing=False,
+                ),
+            )
+        )
 
 
 # ---------------------------------------------------------------------------

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/src/steerable_agent_runtime/hooks.py

@@ -150,6 +150,18 @@ class CompletionAction:
     reason: str | None = None
 
 
+_COMPLETION_KIND_RANK = {"accept": 0, "narrate": 1, "retry": 2}
+
+
+def _completion_outranks(new: CompletionAction, current: CompletionAction) -> bool:
+    """Prefer forcing another working round over a no-tools summary."""
+    new_rank = _COMPLETION_KIND_RANK[new.kind]
+    old_rank = _COMPLETION_KIND_RANK[current.kind]
+    if new_rank != old_rank:
+        return new_rank > old_rank
+    return new.kind != "accept"
+
+
 @dataclass(slots=True)
 class RetryAction:
     """Outcome of an ``on_request_error`` hook.
@@ -285,7 +297,10 @@ class ChainHooks:
     - ``post_tool_result``: the result threads through each hook in order.
     - ``on_request_error``: the first ``retry`` decision wins; if every hook
       says ``fail``, the first failure reason is surfaced.
-    - ``before_completion``: the first non-``accept`` action wins.
+    - ``before_completion``: every hook runs. ``retry`` outranks
+      ``narrate``, which outranks ``accept``. Same-rank later hooks win,
+      so a trailing delivery gate still forces writes when an earlier
+      validator would only ask for a no-tools summary.
     - ``wrap_up_may_drop_tools``: False if any hook forbids dropping tools.
 
     This is how a product stacks e.g. compaction + spill + retry without the
@@ -364,11 +379,12 @@ class ChainHooks:
     async def before_completion(
         self, draft: CompletionDraft, ctx: LoopContext
     ) -> CompletionAction:
+        picked = CompletionAction(kind="accept")
         for hook in self._hooks:
             action = await hook.before_completion(draft, ctx)
-            if action.kind != "accept":
-                return action
-        return CompletionAction(kind="accept")
+            if _completion_outranks(action, picked):
+                picked = action
+        return picked
 
     def on_stream_chunk(self, chunk: Any, ctx: LoopContext) -> None:
         """Fan the chunk out to every hook; one bad hook must not break the rest."""

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/src/steerable_agent_runtime/loop.py

@@ -76,7 +76,7 @@ from .history import (
     entry_to_dict,
 )
 from .hooks import CompletionDraft, LoopHooks, NoopHooks
-from .llm import LLMMessage, LLMProvider, LLMUsage
+from .llm import ImagePart, LLMMessage, LLMProvider, LLMUsage, TextPart
 from .pseudo import (
     PseudoStreamStripper,
     extract_inline_tool_calls,
@@ -1641,6 +1641,7 @@ class CoreLoop:
 
             breaker_tripped = False
             steer_interrupted = False
+            round_images: list[tuple[str, ImagePart]] = []
             for batch_idx, (batch_safe, batch) in enumerate(batches):
                 if breaker_tripped or steer_interrupted:
                     break
@@ -1845,6 +1846,19 @@ class CoreLoop:
                         else:
                             ctx.consecutive_tool_errors += 1
 
+                    # Pop pixels before spill: a base64 PNG in ``data`` is
+                    # always larger than the 16 KB inline budget, and spilling
+                    # it would hide the image from the next request. OpenAI
+                    # tool messages are text-only, so the pixels ride on a
+                    # user message after this batch (``_append_read_images``).
+                    path = ""
+                    if isinstance(result.data, dict):
+                        path = str(result.data.get("path") or "")
+                    image = _pop_result_image(result)
+                    if image is not None:
+                        if isinstance(result.data, dict):
+                            result.data["pixels"] = "attached"
+                        round_images.append((path or call.name, image))
                     # ── hook: post_tool_result (spill / truncation) ──────
                     result = await self._hooks.post_tool_result(result, call, ctx)
 
@@ -1897,14 +1911,7 @@ class CoreLoop:
                             **({"error": result.error} if result.error else {}),
                         },
                     )
-                    manager.append(
-                        LLMMessage.text_of(
-                            "tool",
-                            _result_content(result),
-                            name=call.name,
-                            tool_call_id=call.id,
-                        )
-                    )
+                    manager.append(_tool_result_message(call, result))
 
                     # Approval abort ends the turn: record the batch like the
                     # breaker does (real results for executed calls, synthetic
@@ -2055,6 +2062,7 @@ class CoreLoop:
             # above — skip the "executing" bookkeeping and run the wrap-up
             # round directly. Artifact wrap-up still executes tools, so it
             # falls through and increments like a normal round.
+            _append_read_images(manager, round_images)
             if wrap_up and withholding_tools():
                 continue
             if wrap_up:
@@ -2459,6 +2467,57 @@ def _step_summary(
     }
 
 
+_MAX_READ_IMAGES_PER_ROUND = 4
+
+
+def _pop_result_image(result: ToolResult) -> ImagePart | None:
+    """Take ``data._image`` off the payload so spill and JSON never carry it."""
+    data = result.data
+    if not isinstance(data, dict):
+        return None
+    blob = data.pop("_image", None)
+    if not isinstance(blob, dict):
+        return None
+    b64 = blob.get("b64")
+    media = blob.get("media_type") or "image/png"
+    if not isinstance(b64, str) or not b64:
+        return None
+    return ImagePart.from_base64(b64, media_type=str(media))
+
+
+def _tool_result_message(call: ToolCall, result: ToolResult) -> LLMMessage:
+    """Tool observation as text. OpenAI forbids image_url on role=tool."""
+    return LLMMessage.text_of(
+        "tool", _result_content(result), name=call.name, tool_call_id=call.id
+    )
+
+
+def _append_read_images(
+    manager: ContextManager, images: list[tuple[str, ImagePart]]
+) -> None:
+    """Put PNG/JPEG pixels on a user turn after the tool-result batch.
+
+    OpenAI ``ChatCompletionToolMessageParam.content`` is string or text
+    parts only. Claude Code's Anthropic wire can nest images in
+    ``tool_result``; the Harbor GLM cell is OpenAI-compat, so the pixels
+    follow the tool JSON as a user message instead.
+    """
+    if not images:
+        return
+    kept = images[:_MAX_READ_IMAGES_PER_ROUND]
+    parts: list = [
+        TextPart(
+            "Pixels from the files just read. The tool JSON is an ASCII "
+            "preview; look at these images for the actual contents."
+        )
+    ]
+    for path, image in kept:
+        if path:
+            parts.append(TextPart(f"\n{path}:"))
+        parts.append(image)
+    manager.append(LLMMessage(role="user", content=parts), kind="tool.image")
+
+
 def _result_content(result: ToolResult) -> str:
     """Serialize a ToolResult into the tool-message content for the transcript."""
 
@@ -2468,7 +2527,10 @@ def _result_content(result: ToolResult) -> str:
     if result.error:
         payload["error"] = result.error
     if result.data is not None:
-        payload["data"] = result.data
+        data = result.data
+        if isinstance(data, dict) and "_image" in data:
+            data = {k: v for k, v in data.items() if k != "_image"}
+        payload["data"] = data
     if result.message:
         payload["message"] = result.message
     return json.dumps(payload, ensure_ascii=False)

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/src/steerable_agent_runtime/reminders.py

@@ -71,7 +71,7 @@ class AbandonedRecoveryReminder(ContextFragment):
 
 
 class RunawayExplorationReminder(ContextFragment):
-    """Many tool calls without a single write — exploration without output."""
+    """Many tool calls without a write since the last one."""
 
     content_kind = "reminder.runaway_exploration"
     max_tokens = 200
@@ -81,15 +81,14 @@ class RunawayExplorationReminder(ContextFragment):
 
     def body(self) -> str:
         return (
-            f"[system notice] Exploration without output: {self._calls} tool "
-            "calls so far, none of them a write or edit. If you are still "
-            "exploring, say what you are looking for; if you have what you "
-            "need, produce the artifact now."
+            f"[system notice] {self._calls} tool calls since the last write. "
+            "If the required files already exist, run them; if they do "
+            "not, write them now. Do not keep inspecting source."
         )
 
     @classmethod
     def type_markers(cls) -> tuple[str, str]:
-        return ("[system notice] Exploration without output:", "")
+        return ("[system notice]", "Do not keep inspecting source.")
 
 
 # ---------------------------------------------------------------------------
@@ -157,7 +156,7 @@ REMINDER_CATALOG: tuple[ReminderEntry, ...] = (
     ),
     ReminderEntry(
         id="exploration.runaway",
-        failure_mode="探索失控：大量读取类调用而零产出",
+        failure_mode="探索失控：连续非写入调用，含写过之后继续只读",
         fragment=RunawayExplorationReminder,
     ),
 )
@@ -190,7 +189,8 @@ class ReminderRules:
     #: Fire ``recovery.error_streak`` when consecutive errors reach this
     #: fraction of the loop's circuit breaker.
     error_streak_ratio: float = 0.5
-    #: Fire ``exploration.runaway`` after this many tool calls without a write.
+    #: Fire ``exploration.runaway`` after this many tool calls without a
+    #: write since the last one (or since the start).
     runaway_calls: int = 12
     #: Re-fire a still-true rule after this many rounds (fade-out is the
     #: point, but every-round spam is noise).
@@ -200,11 +200,11 @@ class ReminderRules:
 class ReminderHooks(NoopHooks):
     """Fires catalog reminders from observed loop state.
 
-    ``post_tool_result`` tracks the signals (error streaks, whether any
-    write happened); ``pre_step`` evaluates the rules and appends a due
-    reminder as the last transcript item before the request — the
-    highest-recency position (W2.2.3). Each rule fires once, then re-fires
-    only after ``refire_rounds`` while its condition still holds.
+    ``post_tool_result`` tracks error streaks and consecutive non-write
+    calls (a write resets that streak; a prior write does not silence
+    later inspect-only runs). ``pre_step`` appends a due reminder as the
+    last transcript item before the request. Each rule fires once, then
+    re-fires only after ``refire_rounds`` while its condition still holds.
     """
 
     def __init__(
@@ -217,14 +217,14 @@ class ReminderHooks(NoopHooks):
         self._rules = rules or ReminderRules()
         self._max_tool_errors = max_tool_errors
         self._write_tools = write_tools
-        self._saw_write = False
-        self._calls = 0
+        self._since_write = 0
         self._fired_at: dict[str, int] = {}
 
     async def post_tool_result(self, result: Any, call: Any, ctx: Any) -> Any:
-        self._calls += 1
         if call.name in self._write_tools and getattr(result, "success", False):
-            self._saw_write = True
+            self._since_write = 0
+        else:
+            self._since_write += 1
         return result
 
     async def pre_step(self, transcript: Any, ctx: Any) -> PreStepAction:
@@ -261,8 +261,7 @@ class ReminderHooks(NoopHooks):
             self._fired_at["recovery.error_streak"] = round_index
             return "recovery.error_streak"
         if (
-            self._calls >= self._rules.runaway_calls
-            and not self._saw_write
+            self._since_write >= self._rules.runaway_calls
             and ready("exploration.runaway")
         ):
             self._fired_at["exploration.runaway"] = round_index
@@ -275,5 +274,5 @@ class ReminderHooks(NoopHooks):
                 getattr(ctx, "consecutive_tool_errors", 0), self._max_tool_errors
             )
         if entry.id == "exploration.runaway":
-            return RunawayExplorationReminder(self._calls)
+            return RunawayExplorationReminder(self._since_write)
         return entry.fragment()

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/src/steerable_agent_runtime/skills.py

@@ -397,9 +397,12 @@ def _parse_skill_dir(skill_dir: Path) -> SkillDefinition | None:
     model_invocable = fm.get("disable-model-invocation") is not True
 
     # Same `{scripts}` resolution as the TS prompt assembly: point at the
-    # skill's own scripts/ directory with uniform separators.
+    # skill's own scripts/ directory with uniform separators. The re.sub
+    # replacement MUST be a lambda: on Windows scripts_path carries
+    # backslashes, and a plain-string replacement would have its `\U`, `\n`
+    # etc. interpreted as regex escapes (re.error: bad escape \U).
     scripts_path = str(skill_dir / "scripts")
-    content = re.sub(r"\{scripts\}[/\\]", scripts_path + "/", content)
+    content = re.sub(r"\{scripts\}[/\\]", lambda _m: scripts_path + "/", content)
     content = content.replace("{scripts}", scripts_path)
 
     return SkillDefinition(

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/src/steerable_agent_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.4.0
+Version: 0.5.0
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/tests/test_harness.py

@@ -164,6 +164,31 @@ async def test_null_validator_accepts() -> None:
     assert action.kind == "accept"
 
 
+def test_self_critique_passes_the_instruction_into_the_judge() -> None:
+    """Harbor's self_critique arm is a silent no-op if user_question stays
+    empty: claimed/eager-deferred need exec intent, and the grounding judge
+    is prompted with an empty 用户提问."""
+    from steerable_agent_runtime.harness import SelfCritique
+
+    class _Provider:
+        name = "fake"
+        model = "fake-model"
+
+    hooks = SelfCritique(user_question="Write /app/out.txt").hooks(
+        provider=_Provider()
+    )
+    config = hooks._inner._config
+    assert config.user_question.startswith("Execute the following.")
+    assert "Write /app/out.txt" in config.user_question
+    assert config.tools_available is True
+    assert config.enable_routing is False
+
+    already = SelfCritique(user_question="execute the hidden tests").hooks(
+        provider=_Provider()
+    )
+    assert already._inner._config.user_question == "execute the hidden tests"
+
+
 # -- tools -------------------------------------------------------------------
 
 

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/tests/test_hooks.py

@@ -15,6 +15,8 @@ from steerable_agent_protocol.generated import ToolCall, ToolResult
 
 from steerable_agent_runtime import (
     ChainHooks,
+    CompletionAction,
+    CompletionDraft,
     CoreLoop,
     LoopEvent,
     NoopHooks,
@@ -254,6 +256,60 @@ async def test_chain_hooks_appends_only_compose_in_order() -> None:
     assert [a.message.content_text for a in action.appends] == ["A", "B"]
 
 
+# ---------------------------------------------------------------------------
+# before_completion
+# ---------------------------------------------------------------------------
+
+
+def _draft(**overrides: Any) -> CompletionDraft:
+    values = dict(
+        status="failed",
+        reason="empty",
+        content="",
+        round_index=3,
+        had_tool_calls=False,
+        tool_calls_used=4,
+        tool_successes=2,
+    )
+    values.update(overrides)
+    return CompletionDraft(**values)
+
+
+class _Narrate(NoopHooks):
+    async def before_completion(self, draft, ctx):
+        return CompletionAction(kind="narrate", reason="narration")
+
+
+class _RetryWrite(NoopHooks):
+    async def before_completion(self, draft, ctx):
+        return CompletionAction(kind="retry", reason="empty_round")
+
+
+@pytest.mark.asyncio
+async def test_chain_before_completion_retry_outranks_earlier_narrate() -> None:
+    hooks = ChainHooks(_Narrate(), _RetryWrite())
+    action = await hooks.before_completion(_draft(), ctx=None)  # type: ignore[arg-type]
+    assert action == CompletionAction(kind="retry", reason="empty_round")
+
+
+@pytest.mark.asyncio
+async def test_chain_before_completion_retry_outranks_later_narrate() -> None:
+    hooks = ChainHooks(_RetryWrite(), _Narrate())
+    action = await hooks.before_completion(_draft(), ctx=None)  # type: ignore[arg-type]
+    assert action == CompletionAction(kind="retry", reason="empty_round")
+
+
+@pytest.mark.asyncio
+async def test_chain_before_completion_later_retry_wins_same_kind() -> None:
+    class _FirstRetry(NoopHooks):
+        async def before_completion(self, draft, ctx):
+            return CompletionAction(kind="retry", reason="deferred_execution")
+
+    hooks = ChainHooks(_FirstRetry(), _RetryWrite())
+    action = await hooks.before_completion(_draft(), ctx=None)  # type: ignore[arg-type]
+    assert action == CompletionAction(kind="retry", reason="empty_round")
+
+
 # ---------------------------------------------------------------------------
 # post_tool_result
 # ---------------------------------------------------------------------------

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/tests/test_long_session.py

@@ -147,7 +147,7 @@ async def test_long_session_old_results_folded_in_late_requests() -> None:
 
 @pytest.mark.asyncio
 async def test_long_session_runaway_reminder_fires() -> None:
-    """35 reads without a single write is the runaway-exploration failure
+    """35 reads without a write is the runaway-exploration failure
     mode; the reminder must land at the highest-recency position."""
     provider, _ = await _run_session(
         ChainHooks(ReminderHooks(max_tool_errors=16, rules=None))
@@ -155,9 +155,9 @@ async def test_long_session_runaway_reminder_fires() -> None:
     hits = [
         call
         for call in provider.calls
-        if any("Exploration without output" in m.content_text for m in call)
+        if any("tool calls since the last write" in m.content_text for m in call)
     ]
     assert hits, "runaway reminder never fired"
     # Recency: in the firing request the reminder is the LAST message.
     firing = hits[0]
-    assert "Exploration without output" in firing[-1].content_text
+    assert "tool calls since the last write" in firing[-1].content_text

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/tests/test_loop.py

@@ -123,6 +123,195 @@ async def test_tool_round_then_completion() -> None:
     assert '"success": true' in tool_msgs[0].content_text
 
 
+@pytest.mark.asyncio
+async def test_tool_result_image_reaches_the_next_request() -> None:
+    """OpenAI tool messages are text-only; pixels follow as a user turn."""
+    from steerable_agent_runtime.llm.parts import ImagePart
+    from steerable_agent_runtime.llm.openai_compat import _encode_message
+
+    provider = make_provider(
+        [
+            {"content": "", "tool_calls": [tc("peek")]},
+            {"content": "saw it"},
+        ]
+    )
+    router = ToolRouter()
+
+    async def peek() -> ToolResult:
+        return ToolResult(
+            success=True,
+            data={
+                "path": "/app/code.png",
+                "content": "PNG 4x2 ASCII preview",
+                "kind": "png_ascii",
+                "_image": {"b64": "QUJD", "media_type": "image/png"},
+            },
+        )
+
+    router.register(peek)
+    loop = CoreLoop(provider, RouterToolExecutor(router))
+    await collect(loop.run([LLMMessage.text_of("user", "look")]))
+    second = provider.calls[1]
+    tool_msgs = [m for m in second if m.role == "tool"]
+    assert len(tool_msgs) == 1
+    assert "_image" not in tool_msgs[0].content_text
+    assert "pixels" in tool_msgs[0].content_text
+    assert isinstance(_encode_message(tool_msgs[0])["content"], str)
+    image_msgs = [
+        m for m in second if m.role == "user" and any(isinstance(p, ImagePart) for p in m.content)
+    ]
+    assert len(image_msgs) == 1
+    tool_i = next(i for i, m in enumerate(second) if m.role == "tool")
+    img_i = next(i for i, m in enumerate(second) if m is image_msgs[0])
+    assert tool_i < img_i
+    encoded = _encode_message(image_msgs[0])
+    assert encoded["role"] == "user"
+    assert encoded["content"][-1] == {
+        "type": "image_url",
+        "image_url": {"url": "data:image/png;base64,QUJD"},
+    }
+
+
+@pytest.mark.asyncio
+async def test_tool_result_image_survives_spill() -> None:
+    """Pop ``_image`` before spill; a base64 PNG would always exceed 16 KB."""
+    from steerable_agent_runtime.llm.parts import ImagePart
+    from steerable_agent_runtime.spill import InMemorySpillStore, SpillHooks
+
+    b64 = "A" * 20_000
+    provider = make_provider(
+        [
+            {"content": "", "tool_calls": [tc("peek")]},
+            {"content": "saw it"},
+        ]
+    )
+    router = ToolRouter()
+
+    async def peek() -> ToolResult:
+        return ToolResult(
+            success=True,
+            data={
+                "path": "/app/code.png",
+                "content": "PNG ASCII preview",
+                "kind": "png_ascii",
+                "_image": {"b64": b64, "media_type": "image/png"},
+            },
+        )
+
+    router.register(peek)
+    loop = CoreLoop(
+        provider,
+        RouterToolExecutor(router),
+        hooks=SpillHooks(InMemorySpillStore(), max_inline_bytes=16_000),
+    )
+    await collect(loop.run([LLMMessage.text_of("user", "look")]))
+    second = provider.calls[1]
+    tool_msgs = [m for m in second if m.role == "tool"]
+    assert "_image" not in tool_msgs[0].content_text
+    assert '"spilled": true' not in tool_msgs[0].content_text
+    image_msgs = [
+        m for m in second if m.role == "user" and any(isinstance(p, ImagePart) for p in m.content)
+    ]
+    assert len(image_msgs) == 1
+    image = next(p for p in image_msgs[0].content if isinstance(p, ImagePart))
+    assert image.source == b64
+
+
+@pytest.mark.asyncio
+async def test_two_read_images_share_one_user_message_after_tools() -> None:
+    """OpenAI pairing: all tool messages, then one user turn with both images."""
+    from steerable_agent_runtime.llm.parts import ImagePart
+
+    provider = make_provider(
+        [
+            {
+                "content": "",
+                "tool_calls": [
+                    tc("peek_a", call_id="c_a"),
+                    tc("peek_b", call_id="c_b"),
+                ],
+            },
+            {"content": "saw both"},
+        ]
+    )
+    router = ToolRouter()
+
+    async def peek_a() -> ToolResult:
+        return ToolResult(
+            success=True,
+            data={
+                "path": "/app/a.png",
+                "content": "A",
+                "_image": {"b64": "QQ==", "media_type": "image/png"},
+            },
+        )
+
+    async def peek_b() -> ToolResult:
+        return ToolResult(
+            success=True,
+            data={
+                "path": "/app/b.png",
+                "content": "B",
+                "_image": {"b64": "Qg==", "media_type": "image/png"},
+            },
+        )
+
+    router.register(peek_a)
+    router.register(peek_b)
+    loop = CoreLoop(provider, RouterToolExecutor(router))
+    await collect(loop.run([LLMMessage.text_of("user", "look")]))
+    second = provider.calls[1]
+    roles = [m.role for m in second]
+    tool_idxs = [i for i, role in enumerate(roles) if role == "tool"]
+    image_idxs = [
+        i
+        for i, m in enumerate(second)
+        if m.role == "user" and any(isinstance(p, ImagePart) for p in m.content)
+    ]
+    assert len(tool_idxs) == 2
+    assert len(image_idxs) == 1
+    assert tool_idxs[-1] < image_idxs[0]
+    images = [p for p in second[image_idxs[0]].content if isinstance(p, ImagePart)]
+    assert [p.source for p in images] == ["QQ==", "Qg=="]
+
+
+@pytest.mark.asyncio
+async def test_read_images_cap_at_four_per_round() -> None:
+    from steerable_agent_runtime.llm.parts import ImagePart
+
+    names = [f"peek{i}" for i in range(5)]
+    provider = make_provider(
+        [
+            {"content": "", "tool_calls": [tc(n) for n in names]},
+            {"content": "saw it"},
+        ]
+    )
+    router = ToolRouter()
+    for i, name in enumerate(names):
+        async def peek(
+            path: str = f"/app/{i}.png", b64: str = f"IMG{i}"
+        ) -> ToolResult:
+            return ToolResult(
+                success=True,
+                data={
+                    "path": path,
+                    "content": "preview",
+                    "_image": {"b64": b64, "media_type": "image/png"},
+                },
+            )
+
+        router.register(peek, name=name)
+    loop = CoreLoop(provider, RouterToolExecutor(router))
+    await collect(loop.run([LLMMessage.text_of("user", "look")]))
+    second = provider.calls[1]
+    image_msgs = [
+        m for m in second if m.role == "user" and any(isinstance(p, ImagePart) for p in m.content)
+    ]
+    assert len(image_msgs) == 1
+    images = [p for p in image_msgs[0].content if isinstance(p, ImagePart)]
+    assert [p.source for p in images] == ["IMG0", "IMG1", "IMG2", "IMG3"]
+
+
 @pytest.mark.asyncio
 async def test_loop_echoes_reasoning_details_after_tools() -> None:
     """OpenRouter GLM continues thinking only if the prior details come back."""

{steerable_agent_runtime-0.4.0 → steerable_agent_runtime-0.5.0}/tests/test_reminders.py

@@ -91,7 +91,7 @@ async def test_runaway_exploration_fires_without_writes() -> None:
 
 
 @pytest.mark.asyncio
-async def test_runaway_exploration_silent_after_a_write() -> None:
+async def test_runaway_exploration_silent_right_after_a_write() -> None:
     hooks = ReminderHooks(max_tool_errors=4, rules=ReminderRules(runaway_calls=3))
     ctx = _Ctx(round_index=1)
     for i in range(3):
@@ -109,6 +109,30 @@ async def test_runaway_exploration_silent_after_a_write() -> None:
     assert not action.appends
 
 
+@pytest.mark.asyncio
+async def test_runaway_exploration_fires_after_write_then_inspect() -> None:
+    """make-mips 33547943349: vm.js existed, then 200 bash greps. A lifetime
+    write flag would have silenced the reminder for the rest of the run."""
+    hooks = ReminderHooks(max_tool_errors=4, rules=ReminderRules(runaway_calls=3))
+    ctx = _Ctx(round_index=1)
+    await hooks.post_tool_result(
+        ToolResult(success=True, data={}),
+        ToolCall(id="w", name="write_file", arguments={}),
+        ctx,
+    )
+    for i in range(3):
+        await hooks.post_tool_result(
+            ToolResult(success=True, data={}),
+            ToolCall(id=str(i), name="read_file", arguments={}),
+            ctx,
+        )
+    action = await hooks.pre_step([], ctx)
+    assert action.appends
+    fragment = action.appends[0].fragment
+    assert isinstance(fragment, RunawayExplorationReminder)
+    assert "3 tool calls since the last write" in fragment.render()
+
+
 @pytest.mark.asyncio
 async def test_refire_waits_for_the_configured_gap() -> None:
     hooks = ReminderHooks(