mortal/strix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: collapse dual stat buckets, prune unused params, kill dead helpers

Browse Source 
Tracer:
- Collapse the ``live`` / ``completed`` LLM stat buckets into one
  flat dict. The ``completed`` bucket was only ever written by tests
  — production never moved stats across, and ``get_total_llm_stats``
  always summed both for display.
- Drop ``record_llm_usage(agent_id=...)``: argument was unused, and
  the per-call ``bucket=`` knob is gone with the buckets.

run_config_factory:
- Drop unused ``parallel_tool_calls``, ``tool_choice`` parameters
  from ``make_run_config`` — no caller ever overrode them.
- Drop ``agent_name`` from ``make_agent_context`` — set into the
  context dict but no consumer ever read it; the bus's ``names`` map
  is the source of truth.

Wire reasoning_effort through:
- ``Config.get("strix_reasoning_effort")`` is now actually plumbed
  to ``make_run_config`` from ``entry.py``. Previously the env var
  was advertised but never consumed.

Multi-agent graph tools:
- Replace six copies of
  ``inner = ctx.context if isinstance(ctx.context, dict) else {}``
  with a single ``_ctx(ctx)`` helper.

Todo tools:
- Lift the duplicated ``priority_order`` / ``status_order`` dicts
  to module-level ``_PRIORITY_RANK`` / ``_STATUS_RANK`` and replace
  both inline sort lambdas with ``_todo_sort_key``.

Notes tools:
- Delete ``append_note_content`` (and its test): docstring claimed
  it was for an "agents-graph wiki-update hook on agent_finish" that
  was never wired up. Pure dead public API.

Style:
- Drop the ``del ctx`` no-ops from notes / reporting / web_search
  tools. ``ARG001`` is already silenced project-wide for tool
  modules; the ``del`` was cargo-culted.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
0xallam
2026-04-25 12:44:48 -07:00
parent f08ad2a634
commit d959fe2163
13 changed files with 76 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files
strix/entry.py
+7 -2
View File
@@ -18,12 +18,13 @@ from __future__ import annotations
import logging
import uuid
from pathlib import Path
from typing import TYPE_CHECKING, Any
from typing import TYPE_CHECKING, Any, Literal
from agents import Runner
from agents.tracing import add_trace_processor
from strix.agents.factory import build_strix_agent, make_child_factory
from strix.config.config import Config
from strix.orchestration.bus import AgentMessageBus
from strix.orchestration.hooks import StrixOrchestrationHooks
from strix.run_config_factory import (
@@ -254,7 +255,6 @@ async def run_strix_scan(
caido_host_port=bundle["caido_host_port"],
caido_capability=bundle.get("capability"),
agent_id=root_id,
agent_name="strix",
parent_id=None,
tracer=tracer,
model=model,
@@ -265,10 +265,15 @@ async def run_strix_scan(
agent_factory=agent_factory,
)
reasoning = Config.get("strix_reasoning_effort")
reasoning_effort: Literal["low", "medium", "high"] | None = (
reasoning if reasoning in ("low", "medium", "high") else None # type: ignore[assignment]
)
run_config = make_run_config(
sandbox_session=bundle["session"],
sandbox_client=bundle["client"],
model=model,
reasoning_effort=reasoning_effort,
)
task_text = _build_root_task(scan_config)
strix/orchestration/hooks.py
-4
View File
@@ -92,13 +92,9 @@ class StrixOrchestrationHooks(RunHooks[Any]):
if details is not None:
cached = int(getattr(details, "cached_tokens", 0) or 0)
tracer.record_llm_usage(
agent_id=str(agent_id or "unknown"),
input_tokens=int(getattr(usage, "input_tokens", 0) or 0),
output_tokens=int(getattr(usage, "output_tokens", 0) or 0),
cached_tokens=cached,
cost=0.0,
requests=1,
bucket="live",
)
ctx["turn_count"] = int(ctx.get("turn_count", 0)) + 1
except Exception:
strix/run_config_factory.py
+2 -11
View File
@@ -69,8 +69,6 @@ def make_run_config(
*,
sandbox_session: BaseSandboxSession | None,
model: str = "anthropic/claude-sonnet-4-6",
parallel_tool_calls: bool = _PARALLEL_TOOL_CALLS_DEFAULT,
tool_choice: Literal["auto", "required", "none"] | None = "required",
reasoning_effort: Literal["low", "medium", "high"] | None = None,
model_settings_override: ModelSettings | None = None,
sandbox_client: Any | None = None,
@@ -88,9 +86,6 @@ def make_run_config(
for unit tests and dry runs.
model: Model alias passed to ``MultiProvider``. Defaults to the
production Anthropic alias.
parallel_tool_calls: Default ``False`` — the tool server
serializes one task per agent.
tool_choice: Forces tool use per turn unless explicitly relaxed.
reasoning_effort: ``"low" | "medium" | "high"``; routes to
``ModelSettings.reasoning``.
model_settings_override: Optional per-run ``ModelSettings``
@@ -100,8 +95,8 @@ def make_run_config(
supplied without a client.
"""
base_settings = ModelSettings(
parallel_tool_calls=parallel_tool_calls,
tool_choice=tool_choice,
parallel_tool_calls=_PARALLEL_TOOL_CALLS_DEFAULT,
tool_choice="required",
retry=ModelRetrySettings(
max_retries=_DEFAULT_MAX_RETRIES,
backoff=_DEFAULT_BACKOFF,
@@ -113,8 +108,6 @@ def make_run_config(
ModelSettings(reasoning=Reasoning(effort=reasoning_effort)),
)
if model_settings_override is not None:
# ``ModelSettings.resolve`` merges another ModelSettings into self
# with override-wins semantics — exactly what we want.
base_settings = base_settings.resolve(model_settings_override)
sandbox_config = (
@@ -142,7 +135,6 @@ def make_agent_context(
tool_server_host_port: int | None,
caido_host_port: int | None,
agent_id: str,
agent_name: str,
parent_id: str | None,
tracer: Any | None,
model: str = "anthropic/claude-sonnet-4-6",
@@ -175,7 +167,6 @@ def make_agent_context(
"caido_host_port": caido_host_port,
"caido_capability": caido_capability,
"agent_id": agent_id,
"agent_name": agent_name,
"parent_id": parent_id,
"tracer": tracer,
"model": model,
strix/telemetry/tracer.py
+23 -64
View File
@@ -61,24 +61,13 @@ class Tracer:
self.vulnerability_reports: list[dict[str, Any]] = []
self.final_scan_result: str | None = None
# LLM usage roll-up. Two buckets: ``live`` (active agents) and
# ``completed`` (finalized agents — moved here on on_agent_end).
# The orchestration hook chain feeds both via ``record_llm_usage``.
self._llm_stats: dict[str, dict[str, Any]] = {
"live": {
"input_tokens": 0,
"output_tokens": 0,
"cached_tokens": 0,
"cost": 0.0,
"requests": 0,
},
"completed": {
"input_tokens": 0,
"output_tokens": 0,
"cached_tokens": 0,
"cost": 0.0,
"requests": 0,
},
# LLM usage roll-up across all agents in this run.
self._llm_stats: dict[str, Any] = {
"input_tokens": 0,
"output_tokens": 0,
"cached_tokens": 0,
"cost": 0.0,
"requests": 0,
}
self.scan_results: dict[str, Any] | None = None
@@ -679,65 +668,35 @@ class Tracer:
)
def get_total_llm_stats(self) -> dict[str, Any]:
"""Aggregate LLM stats across the live + completed agents.
Reads ``self._llm_stats`` which the orchestration hooks update
per turn via :meth:`record_llm_usage`. The legacy reach-into-
``agents_graph_actions`` globals is gone.
"""
completed = self._llm_stats.get("completed", {}) or {}
live = self._llm_stats.get("live", {}) or {}
total_stats = {
"input_tokens": int(completed.get("input_tokens", 0))
+ int(live.get("input_tokens", 0)),
"output_tokens": int(completed.get("output_tokens", 0))
+ int(live.get("output_tokens", 0)),
"cached_tokens": int(completed.get("cached_tokens", 0))
+ int(live.get("cached_tokens", 0)),
"cost": round(
float(completed.get("cost", 0.0)) + float(live.get("cost", 0.0)),
4,
),
"requests": int(completed.get("requests", 0)) + int(live.get("requests", 0)),
"""Snapshot the run's aggregated LLM usage."""
stats = self._llm_stats
total = {
"input_tokens": int(stats["input_tokens"]),
"output_tokens": int(stats["output_tokens"]),
"cached_tokens": int(stats["cached_tokens"]),
"cost": round(float(stats["cost"]), 4),
"requests": int(stats["requests"]),
}
return {
"total": total_stats,
"total_tokens": total_stats["input_tokens"] + total_stats["output_tokens"],
"total": total,
"total_tokens": total["input_tokens"] + total["output_tokens"],
}
def record_llm_usage(
self,
*,
agent_id: str, # noqa: ARG002
input_tokens: int = 0,
output_tokens: int = 0,
cached_tokens: int = 0,
cost: float = 0.0,
requests: int = 1,
bucket: str = "live",
) -> None:
"""Accumulate LLM usage. Called by the orchestration hooks.
``bucket`` is ``"live"`` for in-flight agents and ``"completed"``
for finalized ones — the SDK's on_agent_end hook moves a child's
running totals from live to completed when it terminates.
"""
target = self._llm_stats.setdefault(
bucket,
{
"input_tokens": 0,
"output_tokens": 0,
"cached_tokens": 0,
"cost": 0.0,
"requests": 0,
},
)
target["input_tokens"] += input_tokens
target["output_tokens"] += output_tokens
target["cached_tokens"] += cached_tokens
target["cost"] += cost
target["requests"] += requests
"""Accumulate LLM usage from the orchestration hooks."""
self._llm_stats["input_tokens"] += input_tokens
self._llm_stats["output_tokens"] += output_tokens
self._llm_stats["cached_tokens"] += cached_tokens
self._llm_stats["cost"] += cost
self._llm_stats["requests"] += requests
def cleanup(self) -> None:
self.save_run_data(mark_complete=True)
strix/tools/agents_graph/tools.py
+10 -7
View File
@@ -42,6 +42,10 @@ def _dump(result: dict[str, Any]) -> str:
return json.dumps(result, ensure_ascii=False, default=str)
def _ctx(ctx: RunContextWrapper) -> dict[str, Any]:
return ctx.context if isinstance(ctx.context, dict) else {}
@strix_tool(timeout=30)
async def view_agent_graph(ctx: RunContextWrapper) -> str:
"""Print the multi-agent tree — every agent, its parent, its status.
@@ -53,7 +57,7 @@ async def view_agent_graph(ctx: RunContextWrapper) -> str:
bullet list with status in brackets; the agent that called this tool
is marked ``← you``.
"""
inner = ctx.context if isinstance(ctx.context, dict) else {}
inner = _ctx(ctx)
bus = inner.get("bus")
me = inner.get("agent_id")
if bus is None:
@@ -108,7 +112,7 @@ async def agent_status(ctx: RunContextWrapper, agent_id: str) -> str:
agent_id: The 8-char id from ``view_agent_graph`` /
``create_agent``.
"""
inner = ctx.context if isinstance(ctx.context, dict) else {}
inner = _ctx(ctx)
bus = inner.get("bus")
if bus is None:
return _dump({"success": False, "error": "Bus not initialized in context."})
@@ -165,7 +169,7 @@ async def send_message_to_agent(
expected). Default ``information``.
priority: ``low`` / ``normal`` / ``high`` / ``urgent``.
"""
inner = ctx.context if isinstance(ctx.context, dict) else {}
inner = _ctx(ctx)
bus = inner.get("bus")
me = inner.get("agent_id")
if bus is None or me is None:
@@ -247,7 +251,7 @@ async def wait_for_message(
returns and you decide whether to keep working or wait
again.
"""
inner = ctx.context if isinstance(ctx.context, dict) else {}
inner = _ctx(ctx)
bus = inner.get("bus")
me = inner.get("agent_id")
if bus is None or me is None:
@@ -338,7 +342,7 @@ async def create_agent(
when starting a clean-slate task.
skills: Comma-separated skill names. Max 5; prefer 1-3.
"""
inner = ctx.context if isinstance(ctx.context, dict) else {}
inner = _ctx(ctx)
bus = inner.get("bus")
parent_id = inner.get("agent_id")
factory: Callable[..., SDKAgent] | None = inner.get("agent_factory")
@@ -408,7 +412,6 @@ async def create_agent(
caido_host_port=inner.get("caido_host_port"),
caido_capability=inner.get("caido_capability"),
agent_id=child_id,
agent_name=name,
parent_id=parent_id,
tracer=inner.get("tracer"),
model=inner.get("model", "anthropic/claude-sonnet-4-6"),
@@ -495,7 +498,7 @@ async def agent_finish(
parent (e.g., "prioritize testing X", "spawn an agent to
cover Y").
"""
inner = ctx.context if isinstance(ctx.context, dict) else {}
inner = _ctx(ctx)
bus = inner.get("bus")
me = inner.get("agent_id")
if bus is None or me is None:
strix/tools/notes/__init__.py
+1 -9
View File
@@ -1,15 +1,7 @@
from .tools import (
append_note_content,
create_note,
delete_note,
get_note,
list_notes,
update_note,
)
from .tools import create_note, delete_note, get_note, list_notes, update_note
__all__ = [
"append_note_content",
"create_note",
"delete_note",
"get_note",
strix/tools/notes/tools.py
+1 -22
View File
@@ -246,7 +246,7 @@ def _create_note_impl( # noqa: PLR0911
category: str = "general",
tags: list[str] | None = None,
) -> dict[str, Any]:
"""Create one note. Public — used by ``append_note_content`` and tests."""
"""Create one note. Public — used by tests."""
with _notes_lock:
try:
_ensure_notes_loaded()
@@ -398,22 +398,6 @@ def _delete_note_impl(note_id: str) -> dict[str, Any]:
}
def append_note_content(note_id: str, delta: str) -> dict[str, Any]:
"""Append text to an existing note's content. Used by the agents-graph
wiki-update hook on agent_finish."""
with _notes_lock:
try:
_ensure_notes_loaded()
if note_id not in _notes_storage:
return {"success": False, "error": f"Note with ID '{note_id}' not found"}
note = _notes_storage[note_id]
existing = str(note.get("content") or "")
updated = f"{existing.rstrip()}{delta}"
return _update_note_impl(note_id=note_id, content=updated)
except (ValueError, TypeError) as e:
return {"success": False, "error": f"Failed to append note content: {e}"}
# --- public tools ---------------------------------------------------------
@@ -457,7 +441,6 @@ async def create_note(
category: One of the categories above. Default ``"general"``.
tags: Optional free-form tags.
"""
del ctx
return _dump(
await asyncio.to_thread(_create_note_impl, title, content, category, tags),
)
@@ -489,7 +472,6 @@ async def list_notes(
include_content: When False (default) entries have a preview;
when True the full ``content`` is included.
"""
del ctx
return _dump(
await asyncio.to_thread(
_list_notes_impl,
@@ -508,7 +490,6 @@ async def get_note(ctx: RunContextWrapper, note_id: str) -> str:
Args:
note_id: Note id from ``create_note`` or a ``list_notes`` entry.
"""
del ctx
return _dump(await asyncio.to_thread(_get_note_impl, note_id))
@@ -532,7 +513,6 @@ async def update_note(
content: New content, or ``None`` to keep.
tags: New tags list, or ``None`` to keep.
"""
del ctx
return _dump(
await asyncio.to_thread(
_update_note_impl,
@@ -551,5 +531,4 @@ async def delete_note(ctx: RunContextWrapper, note_id: str) -> str:
Args:
note_id: Note id to delete.
"""
del ctx
return _dump(await asyncio.to_thread(_delete_note_impl, note_id))
strix/tools/reporting/tool.py
-1
View File
@@ -399,7 +399,6 @@ async def create_vulnerability_report(
``fix_before`` (verbatim source), ``fix_after`` (suggested
replacement).
"""
del ctx
result = await asyncio.to_thread(
_do_create,
title=title,
strix/tools/todo/tools.py
+16 -25
View File
@@ -21,6 +21,17 @@ from strix.tools._decorator import strix_tool
VALID_PRIORITIES = ["low", "normal", "high", "critical"]
VALID_STATUSES = ["pending", "in_progress", "done"]
_PRIORITY_RANK = {"critical": 0, "high": 1, "normal": 2, "low": 3}
_STATUS_RANK = {"done": 0, "in_progress": 1, "pending": 2}
def _todo_sort_key(todo: dict[str, Any]) -> tuple[int, int, str]:
return (
_STATUS_RANK.get(todo.get("status", "pending"), 99),
_PRIORITY_RANK.get(todo.get("priority", "normal"), 99),
todo.get("created_at", ""),
)
# Per-agent silo: ``_todos_storage[agent_id][todo_id] = todo_dict``.
# Keyed by ``ctx.context['agent_id']`` so two agents in the same scan
@@ -49,22 +60,10 @@ def _normalize_priority(priority: str | None, default: str = "normal") -> str:
def _sorted_todos(agent_id: str) -> list[dict[str, Any]]:
agent_todos = _get_agent_todos(agent_id)
todos_list: list[dict[str, Any]] = []
for todo_id, todo in agent_todos.items():
entry = todo.copy()
entry["todo_id"] = todo_id
todos_list.append(entry)
priority_order = {"critical": 0, "high": 1, "normal": 2, "low": 3}
status_order = {"done": 0, "in_progress": 1, "pending": 2}
todos_list.sort(
key=lambda x: (
status_order.get(x.get("status", "pending"), 99),
priority_order.get(x.get("priority", "normal"), 99),
x.get("created_at", ""),
),
)
todos_list = [
{**todo, "todo_id": todo_id} for todo_id, todo in _get_agent_todos(agent_id).items()
]
todos_list.sort(key=_todo_sort_key)
return todos_list
@@ -323,15 +322,7 @@ async def list_todos(
entry["todo_id"] = todo_id
todos_list.append(entry)
priority_order = {"critical": 0, "high": 1, "normal": 2, "low": 3}
status_order = {"done": 0, "in_progress": 1, "pending": 2}
todos_list.sort(
key=lambda x: (
status_order.get(x.get("status", "pending"), 99),
priority_order.get(x.get("priority", "normal"), 99),
x.get("created_at", ""),
),
)
todos_list.sort(key=_todo_sort_key)
summary: dict[str, int] = {"pending": 0, "in_progress": 0, "done": 0}
for todo in todos_list:
strix/tools/web_search/tool.py
-1
View File
@@ -121,6 +121,5 @@ async def web_search(ctx: RunContextWrapper, query: str) -> str:
target tech, and the specific question. Treat it like a
ticket title for a senior security engineer.
"""
del ctx
result = await asyncio.to_thread(_do_search, query)
return json.dumps(result, ensure_ascii=False, default=str)
tests/telemetry/test_tracer.py
+1 -7
View File
@@ -258,32 +258,26 @@ def test_events_with_agent_id_include_agent_name(
assert chat_event["actor"]["agent_name"] == "Root Agent"
def test_get_total_llm_stats_aggregates_live_and_completed(
def test_get_total_llm_stats_aggregates_recordings(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
monkeypatch.chdir(tmp_path)
tracer = Tracer("cost-rollup")
set_global_tracer(tracer)
# Live agent (still running).
tracer.record_llm_usage(
agent_id="root-agent",
input_tokens=1_000,
output_tokens=250,
cached_tokens=100,
cost=0.12345,
requests=2,
bucket="live",
)
# Completed agents (finalized — moved by on_agent_end hook).
tracer.record_llm_usage(
agent_id="child-1",
input_tokens=2_000,
output_tokens=500,
cached_tokens=400,
cost=0.54321,
requests=3,
bucket="completed",
)
stats = tracer.get_total_llm_stats()
tests/test_run_config_factory.py
-3
View File
@@ -107,7 +107,6 @@ def test_max_turns_default_is_300() -> None:
tool_server_host_port=None,
caido_host_port=None,
agent_id="root",
agent_name="root",
parent_id=None,
tracer=None,
)
@@ -124,7 +123,6 @@ def test_make_agent_context_full_shape() -> None:
tool_server_host_port=48081,
caido_host_port=48080,
agent_id="agent-1",
agent_name="root",
parent_id=None,
tracer="not-a-real-tracer",
is_whitebox=True,
@@ -154,7 +152,6 @@ def test_make_agent_context_is_whitebox_defaults_false() -> None:
tool_server_host_port=None,
caido_host_port=None,
agent_id="r",
agent_name="root",
parent_id=None,
tracer=None,
)
tests/tools/test_notes_wiki.py
+15 -42
View File
@@ -1,5 +1,7 @@
from pathlib import Path
import pytest
from strix.telemetry.tracer import Tracer, get_global_tracer, set_global_tracer
from strix.tools.notes import tools as notes_actions
@@ -9,7 +11,9 @@ def _reset_notes_state() -> None:
notes_actions._loaded_notes_run_dir = None
def test_wiki_notes_are_persisted_and_removed(tmp_path: Path, monkeypatch) -> None:
def test_wiki_notes_are_persisted_and_removed(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.chdir(tmp_path)
_reset_notes_state()
@@ -48,10 +52,12 @@ def test_wiki_notes_are_persisted_and_removed(tmp_path: Path, monkeypatch) -> No
assert wiki_path.exists() is False
finally:
_reset_notes_state()
set_global_tracer(previous_tracer) # type: ignore[arg-type]
set_global_tracer(previous_tracer)
def test_notes_jsonl_replay_survives_memory_reset(tmp_path: Path, monkeypatch) -> None:
def test_notes_jsonl_replay_survives_memory_reset(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.chdir(tmp_path)
_reset_notes_state()
@@ -108,10 +114,10 @@ def test_notes_jsonl_replay_survives_memory_reset(tmp_path: Path, monkeypatch) -
assert listed_after_delete["total_count"] == 0
finally:
_reset_notes_state()
set_global_tracer(previous_tracer) # type: ignore[arg-type]
set_global_tracer(previous_tracer)
def test_get_note_returns_full_note(tmp_path: Path, monkeypatch) -> None:
def test_get_note_returns_full_note(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.chdir(tmp_path)
_reset_notes_state()
@@ -136,44 +142,11 @@ def test_get_note_returns_full_note(tmp_path: Path, monkeypatch) -> None:
assert result["note"]["content"] == "entrypoints and sinks"
finally:
_reset_notes_state()
set_global_tracer(previous_tracer) # type: ignore[arg-type]
def test_append_note_content_appends_delta(tmp_path: Path, monkeypatch) -> None:
monkeypatch.chdir(tmp_path)
_reset_notes_state()
previous_tracer = get_global_tracer()
tracer = Tracer("append-note-run")
set_global_tracer(tracer)
try:
created = notes_actions._create_note_impl(
title="Repo wiki",
content="base",
category="wiki",
tags=["repo:demo"],
)
assert created["success"] is True
note_id = created["note_id"]
assert isinstance(note_id, str)
appended = notes_actions.append_note_content(
note_id=note_id,
delta="\n\n## Agent Update: worker\nSummary: done",
)
assert appended["success"] is True
loaded = notes_actions._get_note_impl(note_id=note_id)
assert loaded["success"] is True
assert loaded["note"]["content"] == "base\n\n## Agent Update: worker\nSummary: done"
finally:
_reset_notes_state()
set_global_tracer(previous_tracer) # type: ignore[arg-type]
set_global_tracer(previous_tracer)
def test_list_and_get_note_handle_wiki_repersist_oserror_gracefully(
tmp_path: Path, monkeypatch
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.chdir(tmp_path)
_reset_notes_state()
@@ -195,7 +168,7 @@ def test_list_and_get_note_handle_wiki_repersist_oserror_gracefully(
_reset_notes_state()
def _raise_oserror(*_args, **_kwargs) -> None:
def _raise_oserror(*_args: object, **_kwargs: object) -> None:
raise OSError("disk full")
monkeypatch.setattr(notes_actions, "_persist_wiki_note", _raise_oserror)
@@ -211,4 +184,4 @@ def test_list_and_get_note_handle_wiki_repersist_oserror_gracefully(
assert fetched["note"]["content"] == "initial wiki content"
finally:
_reset_notes_state()
set_global_tracer(previous_tracer) # type: ignore[arg-type]
set_global_tracer(previous_tracer)