hermes-plugin-tinyfish 0.3.1__tar.gz → 0.3.3__tar.gz

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project uses semantic versioning.
 
 ## Unreleased
 
+## [0.3.3] - 2026-08-12
+
+### Fixed
+
+- Replaced the unreadable raw dictionary output from `hermes tinyfish usage`
+  with labeled Search and Fetch histories, pagination summaries, and clear
+  partial-failure reporting while preserving `--json` for automation.
+
+## [0.3.2] - 2026-08-11
+
+### Added
+
+- Added automated compatibility coverage for the Hermes 0.20.0 source release,
+  alongside the packaged 0.18.2 and 0.19.0 compatibility jobs.
+- Expanded `hermes tinyfish usage` to report both Search and Fetch operation
+  history, including per-surface success or failure.
+
+### Changed
+
+- Bumped the ephemeral routing context to version 2 with research-paper and
+  publication-year search modes, conditional Fetch validators, and explicit
+  guidance not to silently drop requested controls when native MCP tools are
+  unavailable.
+
+### Fixed
+
+- Made Browser session termination retry documented transient and transport
+  failures within a bounded cleanup budget, honor capped `Retry-After` delays,
+  and stop treating HTTP 404 as successful cleanup.
+
 ## [0.3.1] - 2026-08-04
 
 ### Fixed

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: hermes-plugin-tinyfish
-Version: 0.3.1
+Version: 0.3.3
 Summary: TinyFish Search, Fetch, plain-language routing, update awareness, and optional Browser for Hermes Agent
 Project-URL: Homepage, https://github.com/gabeosx/hermes-plugin-tinyfish
 Project-URL: Documentation, https://github.com/gabeosx/hermes-plugin-tinyfish#readme
@@ -194,8 +194,9 @@ surface:
 - “Search only these domains, in English, after this date, and return page 2”
   uses TinyFish MCP's native `search` tool because the generic search schema
   cannot express all of those controls.
-- “Fetch these URLs using this selector, include image links, and use this
-  cache TTL” uses TinyFish MCP's native `fetch_content` tool.
+- “Find research papers from these publication years” also uses native
+  `search`, while “Fetch these URLs using this selector and conditional ETag”
+  uses native `fetch_content`.
 
 Hermes keeps the visible stored user message clean but persists the exact
 API-bound message in an `api_content` sidecar for prompt-cache replay. The note
@@ -299,8 +300,10 @@ hermes tinyfish doctor --live-paid
   present. It does not mean the access or refresh token is valid.
 - `/tinyfish-status` shows non-networked status inside CLI or gateway sessions;
   `/tinyfish-status live` explicitly runs Search and Fetch checks.
-- `usage` reads TinyFish Fetch operation history; it is not Agent or Browser
-  billing data.
+- `usage` reads TinyFish Search and Fetch operation history independently and
+  prints a labeled, paginated history for people. Use `usage --json` for the raw
+  machine-readable response. It reports per-surface success or failure and is
+  not Agent or Browser billing data.
 - `doctor --live-paid` only creates and closes a TinyFish Browser session. It
   refuses under `deny`, requests approval under `request`, and never prints
   connection URLs or credentials.

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/README.md

@@ -162,8 +162,9 @@ surface:
 - “Search only these domains, in English, after this date, and return page 2”
   uses TinyFish MCP's native `search` tool because the generic search schema
   cannot express all of those controls.
-- “Fetch these URLs using this selector, include image links, and use this
-  cache TTL” uses TinyFish MCP's native `fetch_content` tool.
+- “Find research papers from these publication years” also uses native
+  `search`, while “Fetch these URLs using this selector and conditional ETag”
+  uses native `fetch_content`.
 
 Hermes keeps the visible stored user message clean but persists the exact
 API-bound message in an `api_content` sidecar for prompt-cache replay. The note
@@ -267,8 +268,10 @@ hermes tinyfish doctor --live-paid
   present. It does not mean the access or refresh token is valid.
 - `/tinyfish-status` shows non-networked status inside CLI or gateway sessions;
   `/tinyfish-status live` explicitly runs Search and Fetch checks.
-- `usage` reads TinyFish Fetch operation history; it is not Agent or Browser
-  billing data.
+- `usage` reads TinyFish Search and Fetch operation history independently and
+  prints a labeled, paginated history for people. Use `usage --json` for the raw
+  machine-readable response. It reports per-surface success or failure and is
+  not Agent or Browser billing data.
 - `doctor --live-paid` only creates and closes a TinyFish Browser session. It
   refuses under `deny`, requests approval under `request`, and never prints
   connection URLs or credentials.

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/hermes_plugin_tinyfish/rest_client.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import math
+import time
 from typing import Any, NoReturn, cast
 
 import httpx
@@ -9,8 +11,14 @@ import httpx
 SEARCH_URL = "https://api.search.tinyfish.ai"
 FETCH_URL = "https://api.fetch.tinyfish.ai"
 BROWSER_URL = "https://api.browser.tinyfish.ai"
+SEARCH_USAGE_URL = f"{SEARCH_URL}/usage"
 FETCH_USAGE_URL = f"{FETCH_URL}/usage"
 
+_BROWSER_CLOSE_MAX_ATTEMPTS = 3
+_BROWSER_CLOSE_RETRYABLE_STATUSES = frozenset({409, 429, 500, 503, 504})
+_BROWSER_CLOSE_RETRY_AFTER_CAP_SECONDS = 5.0
+_BROWSER_CLOSE_RETRY_BASE_SECONDS = 0.25
+
 
 class TinyFishRestError(RuntimeError):
     """Raised for TinyFish REST transport or HTTP failures."""
@@ -146,27 +154,87 @@ def create_browser_session(
         raise TinyFishRestError("TinyFish Browser returned invalid JSON") from exc
 
 
-def close_browser_session(session_id: str, *, api_key: str, timeout: float = 15.0) -> bool:
-    try:
-        response = httpx.delete(f"{BROWSER_URL}/{session_id}", headers=_headers(api_key), timeout=timeout)
-        return response.status_code in {200, 201, 202, 204, 404}
-    except httpx.RequestError:
-        return False
+def _browser_close_retry_delay(response: httpx.Response | None, attempt: int) -> float:
+    if response is not None:
+        retry_after = str(response.headers.get("Retry-After", "") or "").strip()
+        if retry_after:
+            try:
+                seconds = float(retry_after)
+            except ValueError:
+                seconds = -1.0
+            if math.isfinite(seconds) and seconds >= 0:
+                return min(seconds, _BROWSER_CLOSE_RETRY_AFTER_CAP_SECONDS)
+    return _BROWSER_CLOSE_RETRY_BASE_SECONDS * (2.0**attempt)
 
 
-def fetch_usage(*, api_key: str, timeout: float = 30.0) -> dict[str, Any]:
-    """Return TinyFish Fetch operation history."""
-
+def close_browser_session(session_id: str, *, api_key: str, timeout: float = 15.0) -> bool:
+    """Terminate a Browser session with bounded transient-failure retries.
+
+    TinyFish returns a 2xx response, normally 204, for successful and
+    idempotent termination. A 404 is not success: it can also mean the session
+    belongs to a different API key. Retry only documented transient statuses
+    and transport failures, keeping process-exit cleanup bounded.
+    """
+
+    url = f"{BROWSER_URL}/{session_id}"
+    for attempt in range(_BROWSER_CLOSE_MAX_ATTEMPTS):
+        response: httpx.Response | None = None
+        try:
+            response = httpx.delete(url, headers=_headers(api_key), timeout=timeout)
+        except httpx.RequestError:
+            retry = True
+        else:
+            if 200 <= response.status_code < 300:
+                return True
+            retry = response.status_code in _BROWSER_CLOSE_RETRYABLE_STATUSES
+
+        if not retry or attempt + 1 >= _BROWSER_CLOSE_MAX_ATTEMPTS:
+            return False
+        delay = _browser_close_retry_delay(response, attempt)
+        if delay > 0:
+            time.sleep(delay)
+    return False
+
+
+def _read_usage(
+    url: str,
+    *,
+    service: str,
+    api_key: str,
+    timeout: float,
+) -> dict[str, Any]:
     try:
-        response = httpx.get(FETCH_USAGE_URL, headers=_headers(api_key), timeout=timeout)
+        response = httpx.get(url, headers=_headers(api_key), timeout=timeout)
         response.raise_for_status()
         return cast(dict[str, Any], response.json())
     except httpx.HTTPStatusError as exc:
-        _raise_http_error("TinyFish Fetch usage", exc)
+        _raise_http_error(service, exc)
     except httpx.RequestError as exc:
-        raise TinyFishRestError(f"Could not reach TinyFish Fetch usage: {exc}") from exc
+        raise TinyFishRestError(f"Could not reach {service}: {exc}") from exc
     except ValueError as exc:
-        raise TinyFishRestError("TinyFish Fetch usage returned invalid JSON") from exc
+        raise TinyFishRestError(f"{service} returned invalid JSON") from exc
+
+
+def search_usage(*, api_key: str, timeout: float = 30.0) -> dict[str, Any]:
+    """Return TinyFish Search operation history."""
+
+    return _read_usage(
+        SEARCH_USAGE_URL,
+        service="TinyFish Search usage",
+        api_key=api_key,
+        timeout=timeout,
+    )
+
+
+def fetch_usage(*, api_key: str, timeout: float = 30.0) -> dict[str, Any]:
+    """Return TinyFish Fetch operation history."""
+
+    return _read_usage(
+        FETCH_USAGE_URL,
+        service="TinyFish Fetch usage",
+        api_key=api_key,
+        timeout=timeout,
+    )
 
 
 def usage(*, api_key: str, timeout: float = 30.0) -> dict[str, Any]:

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/hermes_plugin_tinyfish/routing_context.py

@@ -8,12 +8,12 @@ from typing import Any
 from .config import TINYFISH_MCP_URL, load_config, routing_context_enabled
 from .update_check import UpdateChecker
 
-ROUTING_CONTEXT_MARKER = '<tinyfish-routing-context version="1">'
+ROUTING_CONTEXT_MARKER = '<tinyfish-routing-context version="2">'
 ROUTING_GUIDANCE = f"""{ROUTING_CONTEXT_MARKER}
 TinyFish tool-routing guidance:
 - For ordinary web discovery or reading a page, use Hermes `web_search` or `web_extract`; the TinyFish provider already keeps those calls MCP-first.
-- When the request needs TinyFish-specific controls that the generic schemas cannot express—domain/date/language/location/purpose/pagination filters, selectors, output formats, link or image extraction, cache TTL, or per-URL timeouts—use the native `search` or `fetch_content` tool registered by the `tinyfish` MCP server. Use the exact names Hermes exposes, commonly `mcp__tinyfish__search` and `mcp__tinyfish__fetch_content`.
-- Infer the choice from the user's plain language. Do not ask them to choose MCP versus the plugin, and do not persist per-request controls as configuration."""
+- When the request needs TinyFish-specific controls that the generic schemas cannot express—domain/date/language/location/purpose/pagination filters, news or research-paper modes, publication-year filters, selectors, output formats, link or image extraction, conditional ETag/Last-Modified validators, cache TTL, or per-URL timeouts—use the native `search` or `fetch_content` tool registered by the `tinyfish` MCP server. Use the exact names Hermes exposes, commonly `mcp__tinyfish__search` and `mcp__tinyfish__fetch_content`.
+- Infer the choice from the user's plain language. Do not ask them to choose MCP versus the plugin, and do not persist per-request controls as configuration. If a required native tool is unavailable, use the generic provider only when it can preserve the requested constraints; otherwise explain which control is unavailable rather than silently dropping it."""
 
 
 def tinyfish_mcp_configured(config: dict[str, Any]) -> bool:

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/hermes_plugin_tinyfish/setup_cli.py

@@ -6,6 +6,7 @@ import argparse
 import json
 import os
 import sys
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any, cast
 
@@ -85,7 +86,7 @@ def setup_tinyfish_cli(parser: argparse.ArgumentParser) -> None:
     credits_set.add_argument("policy", choices=list(CREDIT_POLICIES))
     credits_sub.add_parser("reset", help="Reset Browser to deny and remove retired Agent/Profile policy keys")
 
-    usage = sub.add_parser("usage", help="Read TinyFish Fetch operation history")
+    usage = sub.add_parser("usage", help="Read TinyFish Search and Fetch operation history")
     usage.add_argument("--json", action="store_true", help="Print machine-readable JSON")
 
 
@@ -602,19 +603,11 @@ def tinyfish_status_command(
     return "\n".join(_status_lines(status))
 
 
-def _print_json_or_text(payload: dict[str, Any], *, as_json: bool) -> None:
-    if as_json:
-        print(json.dumps(payload, indent=2, sort_keys=True))
-    else:
-        for key, value in payload.items():
-            print(f"{key}: {value}")
-
-
 def _api_key_or_error() -> str | None:
     api_key = _get_env("TINYFISH_API_KEY")
     if not api_key:
         print(
-            "TINYFISH_API_KEY is required for TinyFish Fetch usage and Browser operations.",
+            "TINYFISH_API_KEY is required for TinyFish Search/Fetch usage and Browser operations.",
             file=sys.stderr,
         )
         return None
@@ -709,17 +702,150 @@ def cmd_credits(args: argparse.Namespace) -> int:
     return 2
 
 
+def _usage_surface(
+    reader: Callable[..., dict[str, Any]],
+    *,
+    api_key: str,
+) -> dict[str, Any]:
+    try:
+        return {"success": True, "data": reader(api_key=api_key)}
+    except Exception as exc:  # noqa: BLE001
+        return {"success": False, "error": str(exc)}
+
+
+_USAGE_FIELD_ORDER = (
+    "created_at",
+    "status",
+    "query",
+    "url",
+    "final_url",
+    "title",
+    "description",
+    "domain_type",
+    "location",
+    "language",
+    "author",
+    "published_date",
+    "format",
+    "results_count",
+    "total_results",
+    "text_length",
+    "links_count",
+    "image_links_count",
+    "latency_ms",
+    "request_origin",
+    "id",
+    "request_id",
+    "error",
+)
+
+_USAGE_FIELD_LABELS = {
+    "id": "ID",
+    "url": "URL",
+    "final_url": "Final URL",
+    "latency_ms": "Latency (ms)",
+    "request_id": "Request ID",
+}
+
+
+def _usage_field_label(key: str) -> str:
+    return _USAGE_FIELD_LABELS.get(key, key.replace("_", " ").capitalize())
+
+
+def _usage_value_lines(value: Any) -> list[str]:
+    if value is None:
+        return ["-"]
+    if isinstance(value, bool):
+        return ["yes" if value else "no"]
+    if isinstance(value, list) and all(
+        item is None or isinstance(item, (str, int, float, bool)) for item in value
+    ):
+        return [", ".join(str(item) for item in value) if value else "-"]
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, indent=2, sort_keys=True, ensure_ascii=False).splitlines()
+    return [str(value)]
+
+
+def _usage_items(data: dict[str, Any]) -> list[Any]:
+    for key in ("items", "operations"):
+        value = data.get(key)
+        if isinstance(value, list):
+            return value
+    return []
+
+
+def _usage_summary(data: dict[str, Any], *, shown: int) -> str:
+    noun = "operation" if shown == 1 else "operations"
+    parts = [f"{shown} {noun}"]
+    total = data.get("total")
+    if isinstance(total, int) and not isinstance(total, bool):
+        parts[0] = f"{shown} shown / {total} total"
+    page = data.get("page")
+    total_pages = data.get("total_pages")
+    if isinstance(page, int) and isinstance(total_pages, int):
+        parts.append(f"page {page} of {total_pages}")
+    limit = data.get("limit")
+    if isinstance(limit, int) and not isinstance(limit, bool):
+        parts.append(f"limit {limit}")
+    if isinstance(data.get("has_more"), bool):
+        parts.append(f"more: {'yes' if data['has_more'] else 'no'}")
+    return " | ".join(parts)
+
+
+def _usage_text_lines(payload: dict[str, Any]) -> list[str]:
+    lines = ["TinyFish usage"]
+    surfaces = payload.get("surfaces")
+    if not isinstance(surfaces, dict):
+        return [*lines, "  Invalid usage response."]
+
+    for surface_name in ("search", "fetch"):
+        lines.extend(("", surface_name.capitalize()))
+        result = surfaces.get(surface_name)
+        if not isinstance(result, dict):
+            lines.append("  No response.")
+            continue
+        if not result.get("success"):
+            lines.append(f"  Error: {result.get('error') or 'Unknown error'}")
+            continue
+
+        data = result.get("data")
+        if not isinstance(data, dict):
+            lines.append("  Invalid usage response.")
+            continue
+        items = _usage_items(data)
+        lines.append(f"  {_usage_summary(data, shown=len(items))}")
+        if not items:
+            lines.append("  No operations found on this page.")
+            continue
+
+        for index, item in enumerate(items, start=1):
+            lines.extend(("", f"  Operation {index}"))
+            if not isinstance(item, dict):
+                lines.append(f"    Value: {_usage_value_lines(item)[0]}")
+                continue
+            ordered_keys = [key for key in _USAGE_FIELD_ORDER if key in item]
+            ordered_keys.extend(sorted(str(key) for key in item if key not in ordered_keys))
+            for key in ordered_keys:
+                value_lines = _usage_value_lines(item[key])
+                lines.append(f"    {_usage_field_label(key)}: {value_lines[0]}")
+                lines.extend(f"      {line}" for line in value_lines[1:])
+    return lines
+
+
 def cmd_usage(args: argparse.Namespace) -> int:
     api_key = _api_key_or_error()
     if not api_key:
         return 1
-    try:
-        payload = {
-            "success": True,
-            "surface": "fetch",
-            "data": rest_client.fetch_usage(api_key=api_key),
-        }
-    except Exception as exc:  # noqa: BLE001
-        payload = {"success": False, "surface": "fetch", "error": str(exc)}
-    _print_json_or_text(payload, as_json=bool(getattr(args, "json", False)))
+    surfaces = {
+        "search": _usage_surface(rest_client.search_usage, api_key=api_key),
+        "fetch": _usage_surface(rest_client.fetch_usage, api_key=api_key),
+    }
+    payload = {
+        "success": all(result["success"] for result in surfaces.values()),
+        "surfaces": surfaces,
+    }
+    if bool(getattr(args, "json", False)):
+        print(json.dumps(payload, indent=2, sort_keys=True))
+    else:
+        print("\n".join(_usage_text_lines(payload)))
     return 0 if payload["success"] else 1

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/plugin.yaml

@@ -1,5 +1,5 @@
 name: web-tinyfish
-version: 0.3.1
+version: 0.3.3
 description: "Independent TinyFish provider plugin for Hermes Agent. Adds MCP-first Search/Fetch, plain-language tool routing, update awareness, and optional default-deny Browser infrastructure."
 author: gabeosx
 kind: backend

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hermes-plugin-tinyfish"
-version = "0.3.1"
+version = "0.3.3"
 description = "TinyFish Search, Fetch, plain-language routing, update awareness, and optional Browser for Hermes Agent"
 readme = "README.md"
 requires-python = ">=3.10"

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/tests/test_rest_client.py

@@ -16,11 +16,12 @@ def _response(
     status: int = 200,
     payload: dict[str, Any] | None = None,
     content: bytes | None = None,
+    headers: dict[str, str] | None = None,
 ) -> httpx.Response:
     request = httpx.Request(method, url)
     if content is not None:
-        return httpx.Response(status, content=content, request=request)
-    return httpx.Response(status, json=payload or {}, request=request)
+        return httpx.Response(status, content=content, headers=headers, request=request)
+    return httpx.Response(status, json=payload or {}, headers=headers, request=request)
 
 
 def test_search_sends_supported_query_options(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -163,6 +164,25 @@ def test_fetch_usage_uses_documented_fetch_endpoint(monkeypatch: pytest.MonkeyPa
     }
 
 
+def test_search_usage_uses_documented_search_endpoint(monkeypatch: pytest.MonkeyPatch) -> None:
+    captured: dict[str, Any] = {}
+
+    def fake_get(url: str, **kwargs: Any) -> httpx.Response:
+        captured.update(url=url, **kwargs)
+        return _response("GET", url, payload={"items": []})
+
+    monkeypatch.setattr(rest_client.httpx, "get", fake_get)
+
+    result = rest_client.search_usage(api_key="tf_test", timeout=11.0)
+
+    assert result == {"items": []}
+    assert captured == {
+        "url": "https://api.search.tinyfish.ai/usage",
+        "headers": {"X-API-Key": "tf_test", "Accept": "application/json"},
+        "timeout": 11.0,
+    }
+
+
 def test_usage_is_a_compatibility_wrapper(monkeypatch: pytest.MonkeyPatch) -> None:
     captured: dict[str, Any] = {}
 
@@ -189,6 +209,7 @@ RestCall = Callable[[], dict[str, Any]]
             lambda: rest_client.create_browser_session(api_key="tf_test"),
             "TinyFish Browser",
         ),
+        ("get", lambda: rest_client.search_usage(api_key="tf_test"), "TinyFish Search usage"),
         ("get", lambda: rest_client.fetch_usage(api_key="tf_test"), "TinyFish Fetch usage"),
     ],
 )
@@ -222,6 +243,7 @@ def test_rest_methods_report_http_failures(
             lambda: rest_client.create_browser_session(api_key="tf_test"),
             "TinyFish Browser",
         ),
+        ("get", lambda: rest_client.search_usage(api_key="tf_test"), "TinyFish Search usage"),
         ("get", lambda: rest_client.fetch_usage(api_key="tf_test"), "TinyFish Fetch usage"),
     ],
 )
@@ -250,6 +272,7 @@ def test_rest_methods_report_transport_failures(
             lambda: rest_client.create_browser_session(api_key="tf_test"),
             "TinyFish Browser",
         ),
+        ("get", lambda: rest_client.search_usage(api_key="tf_test"), "TinyFish Search usage"),
         ("get", lambda: rest_client.fetch_usage(api_key="tf_test"), "TinyFish Fetch usage"),
     ],
 )
@@ -268,8 +291,8 @@ def test_rest_methods_report_invalid_json(
         call()
 
 
-@pytest.mark.parametrize("status", [200, 201, 202, 204, 404])
-def test_close_browser_session_accepts_success_and_missing_statuses(
+@pytest.mark.parametrize("status", [200, 201, 202, 204, 299])
+def test_close_browser_session_accepts_any_success_status(
     monkeypatch: pytest.MonkeyPatch, status: int
 ) -> None:
     captured: dict[str, Any] = {}
@@ -286,27 +309,96 @@ def test_close_browser_session_accepts_success_and_missing_statuses(
     assert captured["timeout"] == 9.0
 
 
-def test_close_browser_session_returns_false_for_http_failure(
+def test_close_browser_session_rejects_404_without_retry(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
+    calls = 0
+
+    def fake_delete(url: str, **kwargs: Any) -> httpx.Response:
+        nonlocal calls
+        calls += 1
+        return _response("DELETE", url, status=404)
+
+    monkeypatch.setattr(rest_client.httpx, "delete", fake_delete)
+    monkeypatch.setattr(rest_client.time, "sleep", lambda delay: pytest.fail("must not retry"))
+
+    assert rest_client.close_browser_session("sess_123", api_key="tf_test") is False
+    assert calls == 1
+
+
+@pytest.mark.parametrize("status", [409, 429, 500, 503, 504])
+def test_close_browser_session_retries_documented_transient_statuses(
+    monkeypatch: pytest.MonkeyPatch,
+    status: int,
+) -> None:
+    statuses = iter([status, 204])
+    sleeps: list[float] = []
     monkeypatch.setattr(
         rest_client.httpx,
         "delete",
-        lambda url, **kwargs: _response("DELETE", url, status=500),
+        lambda url, **kwargs: _response("DELETE", url, status=next(statuses)),
     )
+    monkeypatch.setattr(rest_client.time, "sleep", sleeps.append)
 
-    assert rest_client.close_browser_session("sess_123", api_key="tf_test") is False
+    assert rest_client.close_browser_session("sess_123", api_key="tf_test") is True
+    assert sleeps == [0.25]
 
 
-def test_close_browser_session_returns_false_for_transport_failure(
+def test_close_browser_session_honors_bounded_retry_after(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
+    responses = iter(
+        [
+            _response("DELETE", rest_client.BROWSER_URL, status=429, headers={"Retry-After": "60"}),
+            _response("DELETE", rest_client.BROWSER_URL, status=204),
+        ]
+    )
+    sleeps: list[float] = []
+    monkeypatch.setattr(rest_client.httpx, "delete", lambda url, **kwargs: next(responses))
+    monkeypatch.setattr(rest_client.time, "sleep", sleeps.append)
+
+    assert rest_client.close_browser_session("sess_123", api_key="tf_test") is True
+    assert sleeps == [5.0]
+
+
+def test_close_browser_session_retries_transport_failure_then_succeeds(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls = 0
+    sleeps: list[float] = []
+
+    def flaky_delete(url: str, **kwargs: Any) -> httpx.Response:
+        nonlocal calls
+        calls += 1
+        if calls == 1:
+            raise httpx.ConnectError("network unavailable", request=httpx.Request("DELETE", url))
+        return _response("DELETE", url, status=204)
+
+    monkeypatch.setattr(rest_client.httpx, "delete", flaky_delete)
+    monkeypatch.setattr(rest_client.time, "sleep", sleeps.append)
+
+    assert rest_client.close_browser_session("sess_123", api_key="tf_test") is True
+    assert calls == 2
+    assert sleeps == [0.25]
+
+
+def test_close_browser_session_returns_false_after_bounded_retries(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls = 0
+    sleeps: list[float] = []
+
     def fail(url: str, **kwargs: Any) -> httpx.Response:
-        raise httpx.ConnectError("network unavailable", request=httpx.Request("DELETE", url))
+        nonlocal calls
+        calls += 1
+        return _response("DELETE", url, status=503)
 
     monkeypatch.setattr(rest_client.httpx, "delete", fail)
+    monkeypatch.setattr(rest_client.time, "sleep", sleeps.append)
 
     assert rest_client.close_browser_session("sess_123", api_key="tf_test") is False
+    assert calls == 3
+    assert sleeps == [0.25, 0.5]
 
 
 def test_agent_and_profile_rest_methods_are_removed() -> None:

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/tests/test_routing_context.py

@@ -34,9 +34,13 @@ def test_routing_context_defaults_on_only_for_configured_tinyfish_mcp(
     first = context(user_message="ordinary search", conversation_history=[])
 
     assert first is not None
+    assert routing.ROUTING_CONTEXT_MARKER == '<tinyfish-routing-context version="2">'
     assert routing.ROUTING_CONTEXT_MARKER in first["context"]
     assert "`web_search` or `web_extract`" in first["context"]
     assert "`search` or `fetch_content`" in first["context"]
+    assert "research-paper" in first["context"]
+    assert "ETag/Last-Modified" in first["context"]
+    assert "silently dropping" in first["context"]
     assert "plain language" in first["context"]
     assert "persist per-request controls" in first["context"]
 
@@ -79,6 +83,26 @@ def test_routing_guidance_returns_after_compression_removes_marker(
     assert result["context"].count(routing.ROUTING_CONTEXT_MARKER) == 1
 
 
+def test_v1_marker_does_not_suppress_v2_routing_guidance(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(routing, "load_config", _mcp_config)
+    context = routing.TinyFishTurnContext(_FakeUpdateChecker())  # type: ignore[arg-type]
+
+    result = context(
+        conversation_history=[
+            {
+                "role": "user",
+                "content": "search",
+                "api_content": '<tinyfish-routing-context version="1">old guidance',
+            }
+        ]
+    )
+
+    assert result is not None
+    assert routing.ROUTING_CONTEXT_MARKER in result["context"]
+
+
 @pytest.mark.parametrize(
     "config",
     [

{hermes_plugin_tinyfish-0.3.1 → hermes_plugin_tinyfish-0.3.3}/tests/test_setup_cli.py

@@ -715,35 +715,150 @@ def test_credits_reset_removes_retired_keys_and_leaves_browser_denied(
     assert saved[-1]["tinyfish"]["credit_policy"] == {"browser": "deny"}
 
 
-def test_usage_calls_fetch_usage_and_labels_surface(
+def test_usage_calls_search_and_fetch_usage(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    calls: list[str] = []
+    calls: list[tuple[str, str]] = []
     monkeypatch.setattr(cli, "_get_env", lambda name: "tf_secret")
 
+    def search_usage(*, api_key: str) -> dict[str, Any]:
+        calls.append(("search", api_key))
+        return {"items": [{"status": "completed"}]}
+
     def fetch_usage(*, api_key: str) -> dict[str, Any]:
-        calls.append(api_key)
+        calls.append(("fetch", api_key))
         return {"operations": [{"status": "completed"}]}
 
+    monkeypatch.setattr(cli.rest_client, "search_usage", search_usage)
     monkeypatch.setattr(cli.rest_client, "fetch_usage", fetch_usage)
 
     result = cli.cmd_usage(argparse.Namespace(json=True))
     payload = json.loads(capsys.readouterr().out)
 
     assert result == 0
-    assert calls == ["tf_secret"]
+    assert calls == [("search", "tf_secret"), ("fetch", "tf_secret")]
     assert payload == {
         "success": True,
-        "surface": "fetch",
-        "data": {"operations": [{"status": "completed"}]},
+        "surfaces": {
+            "search": {
+                "success": True,
+                "data": {"items": [{"status": "completed"}]},
+            },
+            "fetch": {
+                "success": True,
+                "data": {"operations": [{"status": "completed"}]},
+            },
+        },
     }
     assert "tf_secret" not in json.dumps(payload)
 
 
-def test_usage_failure_keeps_fetch_surface_and_returns_failure(
+def test_usage_text_output_formats_operation_history_for_people(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(cli, "_get_env", lambda name: "tf_secret")
+    monkeypatch.setattr(
+        cli.rest_client,
+        "search_usage",
+        lambda *, api_key: {
+            "items": [
+                {
+                    "id": "search-1",
+                    "query": "Hermes Agent",
+                    "status": "completed",
+                    "results_count": 10,
+                    "latency_ms": 125,
+                    "created_at": "2026-08-12T20:00:00Z",
+                }
+            ],
+            "total": 3,
+            "limit": 1,
+            "page": 1,
+            "total_pages": 3,
+            "has_more": True,
+        },
+    )
+    monkeypatch.setattr(
+        cli.rest_client,
+        "fetch_usage",
+        lambda *, api_key: {
+            "operations": [
+                {
+                    "url": "https://example.com",
+                    "status": "failed",
+                    "error": "timeout",
+                    "created_at": "2026-08-12T20:01:00Z",
+                }
+            ],
+            "total": 1,
+            "limit": 100,
+            "page": 1,
+            "total_pages": 1,
+            "has_more": False,
+        },
+    )
+
+    result = cli.cmd_usage(argparse.Namespace(json=False))
+    output = capsys.readouterr().out
+
+    assert result == 0
+    assert (
+        output
+        == """TinyFish usage
+
+Search
+  1 shown / 3 total | page 1 of 3 | limit 1 | more: yes
+
+  Operation 1
+    Created at: 2026-08-12T20:00:00Z
+    Status: completed
+    Query: Hermes Agent
+    Results count: 10
+    Latency (ms): 125
+    ID: search-1
+
+Fetch
+  1 shown / 1 total | page 1 of 1 | limit 100 | more: no
+
+  Operation 1
+    Created at: 2026-08-12T20:01:00Z
+    Status: failed
+    URL: https://example.com
+    Error: timeout
+"""
+    )
+    assert "{'" not in output
+    assert "tf_secret" not in output
+
+
+def test_usage_text_output_keeps_partial_failure_readable(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
     monkeypatch.setattr(cli, "_get_env", lambda name: "tf_secret")
+    monkeypatch.setattr(cli.rest_client, "search_usage", lambda *, api_key: {"items": []})
+
+    def fail_usage(*, api_key: str) -> dict[str, Any]:
+        raise RuntimeError("usage unavailable")
+
+    monkeypatch.setattr(cli.rest_client, "fetch_usage", fail_usage)
+
+    result = cli.cmd_usage(argparse.Namespace(json=False))
+    output = capsys.readouterr().out
+
+    assert result == 1
+    assert "Search\n  0 operations\n  No operations found on this page." in output
+    assert "Fetch\n  Error: usage unavailable" in output
+
+
+def test_usage_partial_failure_returns_both_surface_results_and_failure(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(cli, "_get_env", lambda name: "tf_secret")
+    monkeypatch.setattr(
+        cli.rest_client,
+        "search_usage",
+        lambda *, api_key: {"items": [{"status": "completed"}]},
+    )
 
     def fail_usage(*, api_key: str) -> dict[str, Any]:
         raise RuntimeError("usage unavailable")
@@ -755,14 +870,22 @@ def test_usage_failure_keeps_fetch_surface_and_returns_failure(
 
     assert result == 1
     assert payload["success"] is False
-    assert payload["surface"] == "fetch"
-    assert payload["error"] == "usage unavailable"
+    assert payload["surfaces"]["search"]["success"] is True
+    assert payload["surfaces"]["fetch"] == {
+        "success": False,
+        "error": "usage unavailable",
+    }
 
 
-def test_usage_without_api_key_fails_before_calling_fetch_usage(
+def test_usage_without_api_key_fails_before_calling_usage_endpoints(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
     monkeypatch.setattr(cli, "_get_env", lambda name: "")
+    monkeypatch.setattr(
+        cli.rest_client,
+        "search_usage",
+        lambda **kwargs: pytest.fail("Search usage must not be called"),
+    )
     monkeypatch.setattr(
         cli.rest_client,
         "fetch_usage",