Open-source AI penetration testing tool to find and fix your app’s vulnerabilities.
Python agentsai-hackingai-penetration-testingai-pentestingai-securityartificial-intelligencebug-bountycode-qualityctf-toolscybersecuritycybersecurity-toolsethical-hackinghackingllm-securityoffensive-securitypenetration-testingpentesting-toolsred-teamingsecuritysecurity-automation
chore: nuke tests/ and the entire test toolchain
0xallama6d578c4a8d9
diff --git a/.gitignore b/.gitignoreindex 94adf289..895fe898 100644--- a/.gitignore+++ b/.gitignore@@ -39,18 +39,6 @@ pip-delete-this-directory.txt.pydevproject.settings/-# Testing-.tox/-.coverage-.coverage.*-.cache-nosetests.xml-coverage.xml-*.cover-.hypothesis/-.pytest_cache/-htmlcov/-# FastAPI.env.local.env.development.localdiff --git a/Makefile b/Makefileindex 5e599a01..d9bdd27f 100644--- a/Makefile+++ b/Makefile@@ -1,4 +1,4 @@-.PHONY: help install dev-install format lint type-check test test-cov clean pre-commit setup-dev+.PHONY: help install dev-install format lint type-check security check-all clean pre-commit setup-dev devhelp:@echo "Available commands:"@@ -13,10 +13,6 @@ help:@echo " security - Run security checks with bandit"@echo " check-all - Run all code quality checks"@echo ""- @echo "Testing:"- @echo " test - Run tests with pytest"- @echo " test-cov - Run tests with coverage reporting"- @echo ""@echo "Development:"@echo " pre-commit - Run pre-commit hooks on all files"@echo " clean - Clean up cache files and artifacts"@@ -59,17 +55,6 @@ security:check-all: format lint type-check security@echo "✅ All code quality checks passed!"-test:- @echo "🧪 Running tests..."- uv run pytest -v- @echo "✅ Tests complete!"--test-cov:- @echo "🧪 Running tests with coverage..."- uv run pytest -v --cov=strix --cov-report=term-missing --cov-report=html- @echo "✅ Tests with coverage complete!"- @echo "📊 Coverage report generated in htmlcov/"-pre-commit:@echo "🔧 Running pre-commit hooks..."uv run pre-commit run --all-files@@ -78,13 +63,10 @@ pre-commit:clean:@echo "🧹 Cleaning up cache files..."find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true- find . -type d -name ".pytest_cache" -exec rm -rf {} + 2>/dev/null || truefind . -type d -name ".mypy_cache" -exec rm -rf {} + 2>/dev/null || truefind . -type d -name ".ruff_cache" -exec rm -rf {} + 2>/dev/null || true- find . -type d -name "htmlcov" -exec rm -rf {} + 2>/dev/null || truefind . -name "*.pyc" -delete 2>/dev/null || true- find . -name ".coverage" -delete 2>/dev/null || true@echo "✅ Cleanup complete!"-dev: format lint type-check test+dev: format lint type-check@echo "✅ Development cycle complete!"diff --git a/pyproject.toml b/pyproject.tomlindex c6183157..0332c1ff 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -71,10 +71,6 @@ dev = ["pyright>=1.1.401","pylint>=3.3.7","bandit>=1.8.3",- "pytest>=8.4.0",- "pytest-asyncio>=1.0.0",- "pytest-cov>=6.1.1",- "pytest-mock>=3.14.1","pre-commit>=4.2.0","black>=25.1.0","isort>=6.0.1",@@ -131,7 +127,6 @@ module = ["textual.*","pyte.*","libtmux.*",- "pytest.*","cvss.*","opentelemetry.*","scrubadub.*",@@ -140,23 +135,6 @@ module = []ignore_missing_imports = true-# Relax strict rules for test files (pytest decorators are not fully typed)-[[tool.mypy.overrides]]-module = ["tests.*"]-disallow_untyped_decorators = false-disallow_untyped_defs = false-# Test fixtures often build raw dicts that match SDK TypedDict unions-# structurally; type:ignore-per-line would be very noisy.-disable_error_code = [- "typeddict-item", # TypedDict key access on union variants- "typeddict-unknown-key",- "type-arg", # generic params on dict/MagicMock in test helpers- "no-untyped-call", # SDK has untyped __init__ in some places- "no-any-return", # test helpers often return Any from typed call_args- "arg-type", # fakes pass mocks where SDK wants strict types- "attr-defined", # fake objects monkey-patch attrs-]-# ============================================================================# Ruff Configuration (Fast Python Linter & Formatter)# ============================================================================@@ -167,7 +145,6 @@ line-length = 100extend-exclude = [".git",".mypy_cache",- ".pytest_cache",".ruff_cache","__pycache__","build",@@ -203,7 +180,6 @@ select = ["PIE", # flake8-pie"T20", # flake8-print"PYI", # flake8-pyi- "PT", # flake8-pytest-style"Q", # flake8-quotes"RSE", # flake8-raise"RET", # flake8-return@@ -246,17 +222,6 @@ ignore = ["strix/tools/notes/tools.py" = ["PLC0415", "TC002"]"strix/tools/finish/tool.py" = ["PLC0415", "TC002"]"strix/tools/reporting/tool.py" = ["PLC0415", "TC002"]-"tests/**/*.py" = [- "S105", # Possible hardcoded password (string literal)- "S106", # Possible hardcoded password (function call)- "S108", # Possible insecure usage of temporary file/directory- "ARG001", # Unused function argument- "ARG002", # Unused method argument (test helpers / fakes mirror SDK signatures)- "PLR2004", # Magic value used in comparison- "PT018", # Multi-part assertions are a pytest style preference- "TC002", # Type-only third-party import (tests import for runtime instantiation)- "TC003", # Type-only stdlib import-]"strix/tools/**/*.py" = ["ARG001", # Unused function argument (tools may have unused args for interface consistency)]@@ -409,53 +374,11 @@ ensure_newline_before_comments = trueknown_first_party = ["strix"]known_third_party = ["fastapi", "pydantic", "litellm"]-# ============================================================================-# Pytest Configuration-# ============================================================================--[tool.pytest.ini_options]-minversion = "6.0"-addopts = [- "--strict-markers",- "--strict-config",- "--cov=strix",- "--cov-report=term-missing",- "--cov-report=html",- "--cov-report=xml",-]-testpaths = ["tests"]-python_files = ["test_*.py", "*_test.py"]-python_functions = ["test_*"]-python_classes = ["Test*"]-asyncio_mode = "auto"--[tool.coverage.run]-source = ["strix"]-omit = [- "*/tests/*",- "*/migrations/*",- "*/__pycache__/*"-]--[tool.coverage.report]-exclude_lines = [- "pragma: no cover",- "def __repr__",- "if self.debug:",- "if settings.DEBUG",- "raise AssertionError",- "raise NotImplementedError",- "if 0:",- "if __name__ == .__main__.:",- "class .*\\bProtocol\\):",- "@(abc\\.)?abstractmethod",-]-# ============================================================================# Bandit Configuration (Security Linting)# ============================================================================[tool.bandit]-exclude_dirs = ["tests", "docs", "build", "dist"]+exclude_dirs = ["docs", "build", "dist"]skips = ["B101", "B601", "B404", "B603", "B607"] # Skip assert, shell injection, subprocess import and partial path checksseverity = "medium"diff --git a/tests/__init__.py b/tests/__init__.pydeleted file mode 100644index fda33722..00000000--- a/tests/__init__.py+++ /dev/null@@ -1 +0,0 @@-# Strix Test Suitediff --git a/tests/agents/__init__.py b/tests/agents/__init__.pydeleted file mode 100644index 0be0f17c..00000000--- a/tests/agents/__init__.py+++ /dev/null@@ -1 +0,0 @@-"""Tests for strix.agents module."""diff --git a/tests/agents/test_factory.py b/tests/agents/test_factory.pydeleted file mode 100644index 19029805..00000000--- a/tests/agents/test_factory.py+++ /dev/null@@ -1,200 +0,0 @@-"""Phase 5 tests for the SDK agent factory + prompt renderer.--These two modules are the keystone wiring between Phases 2-4 and an-actual ``Runner.run`` invocation. The tests verify:--- The prompt renderer reuses the existing Jinja template (parity with- legacy LLM._load_system_prompt) and degrades gracefully when the- template isn't available.-- ``build_strix_agent(is_root=True)`` carries ``finish_scan`` and- stops on it; child agents carry ``agent_finish`` and stop on it.-- ``make_child_factory`` snapshots scan-level config into a closure- so each spawned child inherits the right scan_mode / is_whitebox /- prompt context without create_agent having to re-derive it.-"""--from __future__ import annotations--from typing import Any-from unittest.mock import patch--from agents import Agent-from agents.tool import FunctionTool--from strix.agents.factory import build_strix_agent, make_child_factory-from strix.agents.prompt import _resolve_skills, render_system_prompt---# --- prompt renderer -------------------------------------------------------def test_resolve_skills_deduplicates_and_orders() -> None:- out = _resolve_skills(- requested=["recon", "xss", "recon"],- scan_mode="deep",- is_whitebox=False,- )- assert out == ["recon", "xss", "scan_modes/deep"]---def test_resolve_skills_adds_whitebox_pair() -> None:- out = _resolve_skills(requested=None, scan_mode="fast", is_whitebox=True)- # The whitebox pair sits at the tail; scan_modes goes in the middle- # because callers can append more skills after it via the requested arg.- assert out == [- "scan_modes/fast",- "coordination/source_aware_whitebox",- "custom/source_aware_sast",- ]---def test_render_system_prompt_returns_string() -> None:- """Smoke: the StrixAgent template is on disk and renders to non-empty."""- out = render_system_prompt(skills=[], scan_mode="deep")- assert isinstance(out, str)- # The first line of the template starts with 'You are Strix'.- assert out.startswith("You are Strix")---def test_render_system_prompt_swallows_template_errors() -> None:- """If the template path can't be resolved, return an empty string- (not raise) — agent construction must never blow up on prompt load."""- with patch(- "strix.agents.prompt.get_strix_resource_path",- side_effect=RuntimeError("missing"),- ):- out = render_system_prompt(skills=[])- assert out == ""---# --- factory: shape + tools -----------------------------------------------def test_root_agent_carries_finish_scan_and_stops_there() -> None:- agent = build_strix_agent(name="strix", is_root=True)- assert isinstance(agent, Agent)- tool_names = {t.name for t in agent.tools if isinstance(t, FunctionTool)}- assert "finish_scan" in tool_names- assert "agent_finish" not in tool_names- behavior = agent.tool_use_behavior- # StopAtTools is a TypedDict at runtime → behavior is a dict.- assert isinstance(behavior, dict)- assert behavior["stop_at_tool_names"] == ["finish_scan"]---def test_child_agent_carries_agent_finish_and_stops_there() -> None:- agent = build_strix_agent(name="recon-bot", is_root=False)- tool_names = {t.name for t in agent.tools if isinstance(t, FunctionTool)}- assert "agent_finish" in tool_names- assert "finish_scan" not in tool_names- behavior = agent.tool_use_behavior- assert isinstance(behavior, dict)- assert behavior["stop_at_tool_names"] == ["agent_finish"]---def test_root_and_child_share_base_tool_set() -> None:- """The base tool set (think/todo/notes/file_edit/web_search/etc) is- identical between root and child — only the terminator differs."""- root = build_strix_agent(is_root=True)- child = build_strix_agent(is_root=False)- root_names = {t.name for t in root.tools if isinstance(t, FunctionTool)}- child_names = {t.name for t in child.tools if isinstance(t, FunctionTool)}- # Drop the terminators and compare.- assert root_names - {"finish_scan"} == child_names - {"agent_finish"}---def test_agent_includes_graph_and_sandbox_tools() -> None:- """The graph + sandbox tool families are required for parity with- legacy. Spot-check the ones most likely to be forgotten in a refactor."""- agent = build_strix_agent(is_root=True)- names = {t.name for t in agent.tools if isinstance(t, FunctionTool)}- expected = {- "think",- "create_todo",- "create_note",- "web_search",- "str_replace_editor",- "create_vulnerability_report",- "browser_action",- "terminal_execute",- "python_action",- "view_agent_graph",- "agent_status",- "send_message_to_agent",- "wait_for_message",- "create_agent",- }- missing = expected - names- assert not missing, f"missing tools: {missing}"---def test_agent_does_not_include_caido_tools() -> None:- """Caido tools come from CaidoCapability.tools(); the agent doesn't- declare them directly to avoid double-registration when the SDK- runtime merges capability tools."""- agent = build_strix_agent(is_root=True)- names = {t.name for t in agent.tools if isinstance(t, FunctionTool)}- caido = {- "list_requests",- "view_request",- "send_request",- "repeat_request",- "scope_rules",- "list_sitemap",- "view_sitemap_entry",- }- overlap = names & caido- assert overlap == set(), f"unexpected Caido tools in agent.tools: {overlap}"---def test_agent_uses_run_config_model() -> None:- """``model=None`` so the RunConfig drives the model alias through- MultiProvider rather than an SDK default like gpt-4.1."""- agent = build_strix_agent(is_root=True)- assert agent.model is None---def test_agent_instructions_contain_rendered_prompt() -> None:- """The factory must wire the rendered prompt into ``instructions``."""- agent = build_strix_agent(is_root=True, scan_mode="deep")- assert isinstance(agent.instructions, str)- assert agent.instructions.startswith("You are Strix")---# --- child factory ---------------------------------------------------------def test_make_child_factory_returns_callable_that_builds_child() -> None:- factory = make_child_factory(scan_mode="deep", is_whitebox=False)- assert callable(factory)- child = factory(name="sub-1", skills=["recon"])- assert isinstance(child, Agent)- assert child.name == "sub-1"- behavior = child.tool_use_behavior- assert isinstance(behavior, dict)- assert behavior["stop_at_tool_names"] == ["agent_finish"]---def test_make_child_factory_passes_scan_level_config() -> None:- """Verify scan_mode + is_whitebox flow into the rendered prompt- via the closure rather than the create_agent call site."""- captured: dict[str, Any] = {}-- def fake_render(**kwargs: Any) -> str:- captured.update(kwargs)- return "stub-prompt"-- factory = make_child_factory(- scan_mode="fast",- is_whitebox=True,- interactive=True,- system_prompt_context={"scope_source": "test"},- )- with patch("strix.agents.factory.render_system_prompt", side_effect=fake_render):- factory(name="child", skills=["xss"])-- assert captured["scan_mode"] == "fast"- assert captured["is_whitebox"] is True- assert captured["interactive"] is True- assert captured["system_prompt_context"] == {"scope_source": "test"}- assert captured["skills"] == ["xss"]diff --git a/tests/config/__init__.py b/tests/config/__init__.pydeleted file mode 100644index 2edfe312..00000000--- a/tests/config/__init__.py+++ /dev/null@@ -1 +0,0 @@-"""Tests for strix.config module."""diff --git a/tests/config/test_config_override.py b/tests/config/test_config_override.pydeleted file mode 100644index 51f60691..00000000--- a/tests/config/test_config_override.py+++ /dev/null@@ -1,31 +0,0 @@-import json-import os--from strix.config.config import Config, apply_saved_config---def test_apply_config_override_clears_default_only_vars(monkeypatch, tmp_path) -> None:- from strix.interface.main import apply_config_override-- default_cfg = tmp_path / "cli-config.json"- default_cfg.write_text(- json.dumps({"env": {"LLM_API_BASE": "https://default.api", "STRIX_LLM": "default-model"}}),- encoding="utf-8",- )- custom_cfg = tmp_path / "custom.json"- custom_cfg.write_text(json.dumps({"env": {"STRIX_LLM": "custom-model"}}), encoding="utf-8")-- monkeypatch.setattr(Config, "_config_file_override", None)- monkeypatch.setattr(Config, "_applied_from_default", {})- monkeypatch.setattr(Config, "config_dir", classmethod(lambda cls: tmp_path))- for var_name in Config._llm_env_vars():- monkeypatch.delenv(var_name, raising=False)-- apply_saved_config()-- assert os.environ.get("LLM_API_BASE") == "https://default.api"-- apply_config_override(str(custom_cfg))-- assert os.environ.get("STRIX_LLM") == "custom-model"- assert "LLM_API_BASE" not in os.environdiff --git a/tests/config/test_config_telemetry.py b/tests/config/test_config_telemetry.pydeleted file mode 100644index 89af42f9..00000000--- a/tests/config/test_config_telemetry.py+++ /dev/null@@ -1,55 +0,0 @@-import json--from strix.config.config import Config---def test_traceloop_vars_are_tracked() -> None:- tracked = Config.tracked_vars()-- assert "STRIX_OTEL_TELEMETRY" in tracked- assert "STRIX_POSTHOG_TELEMETRY" in tracked- assert "TRACELOOP_BASE_URL" in tracked- assert "TRACELOOP_API_KEY" in tracked- assert "TRACELOOP_HEADERS" in tracked---def test_apply_saved_uses_saved_traceloop_vars(monkeypatch, tmp_path) -> None:- config_path = tmp_path / "cli-config.json"- config_path.write_text(- json.dumps(- {- "env": {- "TRACELOOP_BASE_URL": "https://otel.example.com",- "TRACELOOP_API_KEY": "api-key",- "TRACELOOP_HEADERS": "x-test=value",- }- }- ),- encoding="utf-8",- )-- monkeypatch.setattr(Config, "_config_file_override", config_path)- monkeypatch.delenv("TRACELOOP_BASE_URL", raising=False)- monkeypatch.delenv("TRACELOOP_API_KEY", raising=False)- monkeypatch.delenv("TRACELOOP_HEADERS", raising=False)-- applied = Config.apply_saved()-- assert applied["TRACELOOP_BASE_URL"] == "https://otel.example.com"- assert applied["TRACELOOP_API_KEY"] == "api-key"- assert applied["TRACELOOP_HEADERS"] == "x-test=value"---def test_apply_saved_respects_existing_env_traceloop_vars(monkeypatch, tmp_path) -> None:- config_path = tmp_path / "cli-config.json"- config_path.write_text(- json.dumps({"env": {"TRACELOOP_BASE_URL": "https://otel.example.com"}}),- encoding="utf-8",- )-- monkeypatch.setattr(Config, "_config_file_override", config_path)- monkeypatch.setenv("TRACELOOP_BASE_URL", "https://env.example.com")-- applied = Config.apply_saved(force=False)-- assert "TRACELOOP_BASE_URL" not in applieddiff --git a/tests/conftest.py b/tests/conftest.pydeleted file mode 100644index e698403a..00000000--- a/tests/conftest.py+++ /dev/null@@ -1 +0,0 @@-"""Pytest configuration and shared fixtures for Strix tests."""diff --git a/tests/interface/__init__.py b/tests/interface/__init__.pydeleted file mode 100644index 9261c15d..00000000--- a/tests/interface/__init__.py+++ /dev/null@@ -1 +0,0 @@-"""Tests for strix.interface module."""diff --git a/tests/interface/test_diff_scope.py b/tests/interface/test_diff_scope.pydeleted file mode 100644index 9fe7dd69..00000000--- a/tests/interface/test_diff_scope.py+++ /dev/null@@ -1,153 +0,0 @@-import importlib.util-from pathlib import Path--import pytest---def _load_utils_module():- module_path = Path(__file__).resolve().parents[2] / "strix" / "interface" / "utils.py"- spec = importlib.util.spec_from_file_location("strix_interface_utils_test", module_path)- if spec is None or spec.loader is None:- raise RuntimeError("Failed to load strix.interface.utils for tests")-- module = importlib.util.module_from_spec(spec)- spec.loader.exec_module(module)- return module---utils = _load_utils_module()---def test_parse_name_status_uses_rename_destination_path() -> None:- raw = (- b"R100\x00old/path.py\x00new/path.py\x00"- b"R75\x00legacy/module.py\x00modern/module.py\x00"- b"M\x00src/app.py\x00"- b"A\x00src/new_file.py\x00"- b"D\x00src/deleted.py\x00"- )-- entries = utils._parse_name_status_z(raw)- classified = utils._classify_diff_entries(entries)-- assert "new/path.py" in classified["analyzable_files"]- assert "old/path.py" not in classified["analyzable_files"]- assert "modern/module.py" in classified["analyzable_files"]- assert classified["renamed_files"][0]["old_path"] == "old/path.py"- assert classified["renamed_files"][0]["new_path"] == "new/path.py"- assert "src/deleted.py" in classified["deleted_files"]- assert "src/deleted.py" not in classified["analyzable_files"]---def test_build_diff_scope_instruction_includes_added_modified_and_deleted_guidance() -> None:- scope = utils.RepoDiffScope(- source_path="/tmp/repo",- workspace_subdir="repo",- base_ref="refs/remotes/origin/main",- merge_base="abc123",- added_files=["src/added.py"],- modified_files=["src/changed.py"],- renamed_files=[{"old_path": "src/old.py", "new_path": "src/new.py", "similarity": 90}],- deleted_files=["src/deleted.py"],- analyzable_files=["src/added.py", "src/changed.py", "src/new.py"],- )-- instruction = utils.build_diff_scope_instruction([scope])-- assert "For Added files, review the entire file content." in instruction- assert "For Modified files, focus primarily on the changed areas." in instruction- assert "Note: These files were deleted" in instruction- assert "src/deleted.py" in instruction- assert "src/old.py -> src/new.py" in instruction---def test_resolve_base_ref_prefers_github_base_ref(monkeypatch) -> None:- calls: list[str] = []-- def fake_ref_exists(_repo_path: Path, ref: str) -> bool:- calls.append(ref)- return ref == "refs/remotes/origin/release-2026"-- monkeypatch.setattr(utils, "_git_ref_exists", fake_ref_exists)- monkeypatch.setattr(utils, "_extract_github_base_sha", lambda _env: None)- monkeypatch.setattr(utils, "_resolve_origin_head_ref", lambda _repo_path: None)-- base_ref = utils._resolve_base_ref(- Path("/tmp/repo"),- diff_base=None,- env={"GITHUB_BASE_REF": "release-2026"},- )-- assert base_ref == "refs/remotes/origin/release-2026"- assert calls[0] == "refs/remotes/origin/release-2026"---def test_resolve_base_ref_falls_back_to_remote_main(monkeypatch) -> None:- calls: list[str] = []-- def fake_ref_exists(_repo_path: Path, ref: str) -> bool:- calls.append(ref)- return ref == "refs/remotes/origin/main"-- monkeypatch.setattr(utils, "_git_ref_exists", fake_ref_exists)- monkeypatch.setattr(utils, "_extract_github_base_sha", lambda _env: None)- monkeypatch.setattr(utils, "_resolve_origin_head_ref", lambda _repo_path: None)-- base_ref = utils._resolve_base_ref(Path("/tmp/repo"), diff_base=None, env={})-- assert base_ref == "refs/remotes/origin/main"- assert "refs/remotes/origin/main" in calls- assert "origin/main" not in calls---def test_resolve_diff_scope_context_auto_degrades_when_repo_scope_resolution_fails(- monkeypatch,-) -> None:- source = {"source_path": "/tmp/repo", "workspace_subdir": "repo"}-- monkeypatch.setattr(utils, "_should_activate_auto_scope", lambda *_args, **_kwargs: True)- monkeypatch.setattr(utils, "_is_git_repo", lambda _repo_path: True)- monkeypatch.setattr(- utils,- "_resolve_repo_diff_scope",- lambda *_args, **_kwargs: (_ for _ in ()).throw(ValueError("shallow history")),- )-- result = utils.resolve_diff_scope_context(- local_sources=[source],- scope_mode="auto",- diff_base=None,- non_interactive=True,- env={},- )-- assert result.active is False- assert result.mode == "auto"- assert result.metadata["active"] is False- assert result.metadata["mode"] == "auto"- assert "skipped_diff_scope_sources" in result.metadata- assert result.metadata["skipped_diff_scope_sources"] == [- "/tmp/repo (diff-scope skipped: shallow history)"- ]---def test_resolve_diff_scope_context_diff_mode_still_raises_on_repo_scope_resolution_failure(- monkeypatch,-) -> None:- source = {"source_path": "/tmp/repo", "workspace_subdir": "repo"}-- monkeypatch.setattr(utils, "_is_git_repo", lambda _repo_path: True)- monkeypatch.setattr(- utils,- "_resolve_repo_diff_scope",- lambda *_args, **_kwargs: (_ for _ in ()).throw(ValueError("shallow history")),- )-- with pytest.raises(ValueError, match="shallow history"):- utils.resolve_diff_scope_context(- local_sources=[source],- scope_mode="diff",- diff_base=None,- non_interactive=True,- env={},- )diff --git a/tests/llm/__init__.py b/tests/llm/__init__.pydeleted file mode 100644index 86f5ed8b..00000000--- a/tests/llm/__init__.py+++ /dev/null@@ -1 +0,0 @@-"""Tests for strix.llm module."""diff --git a/tests/llm/test_anthropic_cache_wrapper.py b/tests/llm/test_anthropic_cache_wrapper.pydeleted file mode 100644index d2759a1d..00000000--- a/tests/llm/test_anthropic_cache_wrapper.py+++ /dev/null@@ -1,74 +0,0 @@-"""Smoke tests for AnthropicCachingLitellmModel."""--from __future__ import annotations--from strix.llm.anthropic_cache_wrapper import AnthropicCachingLitellmModel---def _make(model: str) -> AnthropicCachingLitellmModel:- # ``LitellmModel.__init__`` only validates that model is a string; we- # don't need a real API key for in-memory ``_patch`` testing.- return AnthropicCachingLitellmModel(model=model, api_key="test-key")---def test_is_anthropic_detects_anthropic_prefix() -> None:- m = _make("anthropic/claude-3-5-sonnet")- assert m._is_anthropic() is True---def test_is_anthropic_detects_claude_substring() -> None:- m = _make("openrouter/anthropic-claude-haiku")- assert m._is_anthropic() is True---def test_is_anthropic_false_for_openai() -> None:- m = _make("openai/gpt-4o")- assert m._is_anthropic() is False---def test_is_anthropic_false_for_gemini() -> None:- m = _make("gemini/gemini-1.5-pro")- assert m._is_anthropic() is False---def test_patch_anthropic_adds_cache_control_to_system() -> None:- m = _make("anthropic/claude-3-5-sonnet")- items: list = [- {"role": "system", "content": "You are a helpful agent."},- {"role": "user", "content": "hi"},- ]- out = m._patch(items)- assert out[0]["role"] == "system"- content = out[0]["content"]- assert isinstance(content, list)- assert content[0]["type"] == "text"- assert content[0]["text"] == "You are a helpful agent."- assert content[0]["cache_control"] == {"type": "ephemeral"}- # Second item passes through unchanged.- assert out[1] == {"role": "user", "content": "hi"}---def test_patch_non_anthropic_passes_through() -> None:- m = _make("openai/gpt-4o")- items: list = [- {"role": "system", "content": "You are a helpful agent."},- {"role": "user", "content": "hi"},- ]- assert m._patch(items) is items # exact same list reference, no copy---def test_patch_skips_non_string_system_content() -> None:- """If system content is already structured (e.g., previously patched),- don't re-wrap — pass through unchanged."""- m = _make("anthropic/claude-3-5-sonnet")- items: list = [- {"role": "system", "content": [{"type": "text", "text": "x"}]},- {"role": "user", "content": "hi"},- ]- out = m._patch(items)- assert out[0]["content"] == [{"type": "text", "text": "x"}]---def test_patch_handles_empty_list() -> None:- m = _make("anthropic/claude-3-5-sonnet")- assert m._patch([]) == []diff --git a/tests/llm/test_multi_provider_setup.py b/tests/llm/test_multi_provider_setup.pydeleted file mode 100644index 32d8e3ad..00000000--- a/tests/llm/test_multi_provider_setup.py+++ /dev/null@@ -1,42 +0,0 @@-"""Smoke tests for the multi-provider setup."""--from __future__ import annotations--import pytest-from agents.exceptions import UserError--from strix.llm.anthropic_cache_wrapper import AnthropicCachingLitellmModel-from strix.llm.multi_provider_setup import (- _AnthropicCachingProvider,- build_multi_provider,-)---def test_anthropic_provider_wraps_in_caching_model() -> None:- provider = _AnthropicCachingProvider()- model = provider.get_model("claude-sonnet-4-6")- assert isinstance(model, AnthropicCachingLitellmModel)- # The provider re-prefixes with ``anthropic/`` so litellm routes correctly.- assert model.model == "anthropic/claude-sonnet-4-6"- assert model._is_anthropic() is True---def test_anthropic_provider_preserves_existing_anthropic_prefix() -> None:- """If the alias already carries ``anthropic/``, don't double-prefix."""- provider = _AnthropicCachingProvider()- model = provider.get_model("anthropic/claude-3-5-sonnet-20241022")- assert model.model == "anthropic/claude-3-5-sonnet-20241022"---def test_anthropic_provider_empty_name_raises() -> None:- provider = _AnthropicCachingProvider()- with pytest.raises(UserError, match="non-empty"):- provider.get_model(None)---def test_build_multi_provider_routes_anthropic_through_caching_wrapper() -> None:- """The configured MultiProvider should hit our caching wrapper for the- ``anthropic/`` prefix."""- mp = build_multi_provider()- model = mp.get_model("anthropic/claude-sonnet-4-6")- assert isinstance(model, AnthropicCachingLitellmModel)diff --git a/tests/orchestration/__init__.py b/tests/orchestration/__init__.pydeleted file mode 100644index e69de29b..00000000diff --git a/tests/orchestration/test_bus.py b/tests/orchestration/test_bus.pydeleted file mode 100644index 6ccc621f..00000000--- a/tests/orchestration/test_bus.py+++ /dev/null@@ -1,195 +0,0 @@-"""Phase 0 smoke tests for AgentMessageBus."""--from __future__ import annotations--import asyncio--import pytest--from strix.orchestration.bus import AgentMessageBus---def bus() -> AgentMessageBus:- return AgentMessageBus()---async def test_register_records_agent(bus: AgentMessageBus) -> None:- await bus.register("a1", "alpha", parent_id=None)- assert bus.statuses["a1"] == "running"- assert bus.parent_of["a1"] is None- assert bus.names["a1"] == "alpha"- assert bus.inboxes["a1"] == []- assert bus.stats_live["a1"]["calls"] == 0---async def test_send_and_drain_fifo(bus: AgentMessageBus) -> None:- await bus.register("a1", "alpha", parent_id=None)- await bus.send("a1", {"from": "b", "content": "first"})- await bus.send("a1", {"from": "c", "content": "second"})- drained = await bus.drain("a1")- assert [m["content"] for m in drained] == ["first", "second"]- assert await bus.drain("a1") == []---async def test_send_to_unknown_agent_is_dropped(bus: AgentMessageBus) -> None:- await bus.send("ghost", {"from": "user", "content": "x"})- assert "ghost" not in bus.inboxes---async def test_finalize_clears_inbox_parent_name(bus: AgentMessageBus) -> None:- """C13 (AUDIT_R3): finalize cleans up routing state to avoid orphan messages."""- await bus.register("a1", "alpha", parent_id=None)- await bus.register("a2", "beta", parent_id="a1")- await bus.send("a1", {"from": "a2", "content": "hi"})- await bus.finalize("a1", "completed")- # Inbox / parent / name removed so siblings can't accidentally re-fill.- assert "a1" not in bus.inboxes- assert "a1" not in bus.parent_of- assert "a1" not in bus.names- # Status remains for diagnostics.- assert bus.statuses["a1"] == "completed"- # Messages sent to a finalized agent are dropped silently.- await bus.send("a1", {"from": "a2", "content": "ignored"})- assert "a1" not in bus.inboxes---async def test_record_usage_aggregates(bus: AgentMessageBus) -> None:- await bus.register("a1", "alpha", parent_id=None)-- class _Details:- cached_tokens = 10-- class _Usage:- input_tokens = 100- output_tokens = 50- input_tokens_details = _Details()-- await bus.record_usage("a1", _Usage())- await bus.record_usage("a1", _Usage())- stats = bus.stats_live["a1"]- assert stats["in"] == 200- assert stats["out"] == 100- assert stats["cached"] == 20- assert stats["calls"] == 2---async def test_record_usage_handles_none(bus: AgentMessageBus) -> None:- await bus.register("a1", "alpha", parent_id=None)- await bus.record_usage("a1", None)- assert bus.stats_live["a1"]["calls"] == 0---async def test_total_stats_snapshot(bus: AgentMessageBus) -> None:- """C12 (AUDIT_R2): total_stats acquires the lock for a consistent snapshot."""- await bus.register("a1", "alpha", parent_id=None)- await bus.register("a2", "beta", parent_id="a1")-- class _Details:- cached_tokens = 5-- class _Usage:- input_tokens = 10- output_tokens = 20- input_tokens_details = _Details()-- await bus.record_usage("a1", _Usage())- await bus.record_usage("a2", _Usage())- await bus.finalize("a2", "completed")-- totals = await bus.total_stats()- assert totals["in"] == 20- assert totals["out"] == 40- assert totals["cached"] == 10- assert totals["calls"] == 2---async def test_concurrent_send_drain_no_lost_messages() -> None:- bus = AgentMessageBus()- await bus.register("a1", "alpha", parent_id=None)-- async def producer(start: int, count: int) -> None:- for i in range(count):- await bus.send("a1", {"from": "p", "content": str(start + i)})-- # 50 producers x 20 messages = 1000 messages; drain in 1 reader.- producers = [asyncio.create_task(producer(i * 20, 20)) for i in range(50)]- await asyncio.gather(*producers)- drained = await bus.drain("a1")- assert len(drained) == 1000---async def test_cancel_descendants_cancels_whole_tree() -> None:- """C9 (AUDIT_R2): cancel_descendants cancels every transitive child."""- bus = AgentMessageBus()- await bus.register("root", "root", parent_id=None)- await bus.register("child1", "c1", parent_id="root")- await bus.register("grandchild1", "g1", parent_id="child1")- await bus.register("child2", "c2", parent_id="root")-- pending = asyncio.get_event_loop().create_future()-- async def fake_run() -> None:- await pending # block until cancelled-- for aid in ("root", "child1", "grandchild1", "child2"):- bus.tasks[aid] = asyncio.create_task(fake_run())-- await bus.cancel_descendants("root")-- for aid in ("root", "child1", "grandchild1", "child2"):- assert bus.tasks[aid].cancelled() or bus.tasks[aid].done()---async def test_cancel_descendants_triggers_leaves_before_root() -> None:- """C9: explicit ordering check — leaves' .cancel() called before root's."""- bus = AgentMessageBus()- await bus.register("root", "root", parent_id=None)- await bus.register("child1", "c1", parent_id="root")- await bus.register("grandchild1", "g1", parent_id="child1")-- cancel_call_order: list[str] = []- pending = asyncio.get_event_loop().create_future()-- class _RecordingTask:- """Wrap a real Task; record the moment .cancel() is invoked."""-- def __init__(self, name: str, task: asyncio.Task) -> None:- self._name = name- self._task = task-- def done(self) -> bool:- return self._task.done()-- def cancelled(self) -> bool:- return self._task.cancelled()-- def cancel(self, *args: object, **kwargs: object) -> bool:- cancel_call_order.append(self._name)- return self._task.cancel()-- def __await__(self):- return self._task.__await__()-- async def fake_run() -> None:- await pending-- for aid in ("root", "child1", "grandchild1"):- real = asyncio.create_task(fake_run())- bus.tasks[aid] = _RecordingTask(aid, real) # type: ignore[assignment]-- await bus.cancel_descendants("root")-- # grandchild and child must have .cancel() called before root.- assert cancel_call_order.index("grandchild1") < cancel_call_order.index("root")- assert cancel_call_order.index("child1") < cancel_call_order.index("root")diff --git a/tests/orchestration/test_filter.py b/tests/orchestration/test_filter.pydeleted file mode 100644index c38dc0d6..00000000--- a/tests/orchestration/test_filter.py+++ /dev/null@@ -1,95 +0,0 @@-"""Phase 0 smoke tests for inject_messages_filter."""--from __future__ import annotations--from dataclasses import dataclass-from typing import Any--import pytest-from agents.run_config import CallModelData, ModelInputData--from strix.orchestration.bus import AgentMessageBus-from strix.orchestration.filter import inject_messages_filter---@dataclass-class _FakeAgent:- name: str = "agent"---def _call_data(- context: Any,- items: list[Any],- instructions: str | None = "system",-) -> CallModelData[Any]:- return CallModelData(- model_data=ModelInputData(input=items, instructions=instructions),- agent=_FakeAgent(),- context=context,- )---async def test_empty_inbox_passes_through() -> None:- bus = AgentMessageBus()- await bus.register("a1", "alpha", parent_id=None)- data = _call_data({"bus": bus, "agent_id": "a1"}, [{"role": "user", "content": "x"}])-- out = await inject_messages_filter(data)-- assert out.input == [{"role": "user", "content": "x"}]- assert out.instructions == "system"---async def test_pending_messages_appended_in_order() -> None:- bus = AgentMessageBus()- await bus.register("a1", "alpha", parent_id=None)- await bus.send("a1", {"from": "b", "content": "hello", "type": "info", "priority": "normal"})- await bus.send("a1", {"from": "c", "content": "second", "type": "info", "priority": "high"})- data = _call_data({"bus": bus, "agent_id": "a1"}, [{"role": "user", "content": "task"}])-- out = await inject_messages_filter(data)-- assert len(out.input) == 3- assert out.input[0] == {"role": "user", "content": "task"}- assert "Message from agent b" in out.input[1]["content"]- assert "hello" in out.input[1]["content"]- assert "second" in out.input[2]["content"]- assert "priority=high" in out.input[2]["content"]---async def test_user_sender_skips_envelope() -> None:- bus = AgentMessageBus()- await bus.register("a1", "alpha", parent_id=None)- await bus.send("a1", {"from": "user", "content": "follow-up question"})- data = _call_data({"bus": bus, "agent_id": "a1"}, [])-- out = await inject_messages_filter(data)-- assert out.input == [{"role": "user", "content": "follow-up question"}]---async def test_no_bus_in_context_passes_through() -> None:- data = _call_data({"agent_id": "a1"}, [{"role": "user", "content": "x"}])- out = await inject_messages_filter(data)- assert out.input == [{"role": "user", "content": "x"}]---async def test_filter_exception_returns_unmodified() -> None:- """C14 (AUDIT_R3): filter exception is caught; original data returned."""-- class _BrokenBus:- async def drain(self, _: str) -> list[dict[str, Any]]:- raise RuntimeError("simulated bug")-- data = _call_data(- {"bus": _BrokenBus(), "agent_id": "a1"},- [{"role": "user", "content": "still works"}],- )-- out = await inject_messages_filter(data)- assert out.input == [{"role": "user", "content": "still works"}]diff --git a/tests/orchestration/test_hooks.py b/tests/orchestration/test_hooks.pydeleted file mode 100644index 004becb1..00000000--- a/tests/orchestration/test_hooks.py+++ /dev/null@@ -1,174 +0,0 @@-"""Phase 0 smoke tests for StrixOrchestrationHooks."""--from __future__ import annotations--from dataclasses import dataclass, field-from typing import Any--import pytest--from strix.orchestration.bus import AgentMessageBus-from strix.orchestration.hooks import StrixOrchestrationHooks---@dataclass-class _Ctx:- """Minimal stand-in for RunContextWrapper / AgentHookContext.-- Only ``.context`` is exercised by the hooks under test; SDK's real wrappers- expose much more, but the hooks treat ``.context`` as the dict we put in.- """-- context: dict[str, Any] = field(default_factory=dict)---@dataclass-class _Tool:- name: str---class _FakeTracer:- def __init__(self) -> None:- self.starts: list[tuple[str, str]] = []- self.ends: list[tuple[str, str, Any]] = []-- def log_tool_start(self, agent_id: str, tool_name: str) -> None:- self.starts.append((agent_id, tool_name))-- def log_tool_end(self, agent_id: str, tool_name: str, result: Any) -> None:- self.ends.append((agent_id, tool_name, result))---async def test_on_llm_start_injects_85_percent_warning() -> None:- hooks = StrixOrchestrationHooks()- items: list[Any] = []- ctx = _Ctx(context={"max_turns": 100, "turn_count": 85})- await hooks.on_llm_start(ctx, agent=None, system_prompt="x", input_items=items)- assert len(items) == 1- assert "85%" in items[0]["content"]---async def test_on_llm_start_injects_n_minus_3_warning() -> None:- hooks = StrixOrchestrationHooks()- items: list[Any] = []- ctx = _Ctx(context={"max_turns": 100, "turn_count": 97})- await hooks.on_llm_start(ctx, agent=None, system_prompt="x", input_items=items)- assert len(items) == 1- assert "3 iterations left" in items[0]["content"]---async def test_on_llm_start_no_warning_at_other_turns() -> None:- hooks = StrixOrchestrationHooks()- items: list[Any] = []- ctx = _Ctx(context={"max_turns": 100, "turn_count": 50})- await hooks.on_llm_start(ctx, agent=None, system_prompt="x", input_items=items)- assert items == []---async def test_on_llm_end_records_usage_and_increments_turn() -> None:- hooks = StrixOrchestrationHooks()- bus = AgentMessageBus()- await bus.register("a1", "alpha", parent_id=None)- ctx = _Ctx(context={"bus": bus, "agent_id": "a1", "turn_count": 0})-- class _Details:- cached_tokens = 5-- class _Usage:- input_tokens = 10- output_tokens = 20- input_tokens_details = _Details()-- class _Resp:- usage = _Usage()-- await hooks.on_llm_end(ctx, agent=None, response=_Resp())- assert ctx.context["turn_count"] == 1- assert bus.stats_live["a1"]["in"] == 10---async def test_on_agent_end_detects_crash() -> None:- """on_agent_end without agent_finish_called posts crash message to parent."""- hooks = StrixOrchestrationHooks()- bus = AgentMessageBus()- await bus.register("root", "root", parent_id=None)- await bus.register("child", "specialist", parent_id="root")- ctx = _Ctx(context={"bus": bus, "agent_id": "child"})-- await hooks.on_agent_end(ctx, agent=None, output=None) # crashed (output=None)-- drained = await bus.drain("root")- assert len(drained) == 1- assert "[Agent crash]" in drained[0]["content"]- assert "child" in drained[0]["content"]- assert drained[0]["type"] == "crash"- assert bus.statuses["child"] == "crashed"---async def test_on_agent_end_no_crash_when_finish_called() -> None:- hooks = StrixOrchestrationHooks()- bus = AgentMessageBus()- await bus.register("root", "root", parent_id=None)- await bus.register("child", "specialist", parent_id="root")- ctx = _Ctx(- context={- "bus": bus,- "agent_id": "child",- "agent_finish_called": True,- }- )-- await hooks.on_agent_end(ctx, agent=None, output="done")-- assert await bus.drain("root") == []- assert bus.statuses["child"] == "completed"---async def test_on_tool_end_marks_finish_called() -> None:- """When agent_finish or finish_scan returns, mark context flag for crash detection."""- hooks = StrixOrchestrationHooks()- ctx = _Ctx(context={"agent_id": "a1"})- await hooks.on_tool_end(ctx, agent=None, tool=_Tool("agent_finish"), result="ok")- assert ctx.context["agent_finish_called"] is True---async def test_on_tool_end_other_tool_does_not_set_flag() -> None:- hooks = StrixOrchestrationHooks()- ctx = _Ctx(context={"agent_id": "a1"})- await hooks.on_tool_end(ctx, agent=None, tool=_Tool("terminal_execute"), result="x")- assert ctx.context.get("agent_finish_called") is None---async def test_on_tool_start_logs_to_tracer() -> None:- hooks = StrixOrchestrationHooks()- tracer = _FakeTracer()- ctx = _Ctx(context={"tracer": tracer, "agent_id": "a1"})- await hooks.on_tool_start(ctx, agent=None, tool=_Tool("browser_action"))- assert tracer.starts == [("a1", "browser_action")]---async def test_hook_exception_does_not_propagate() -> None:- """C15 (AUDIT_R3): a bug in the hook body must never tear down the run."""- hooks = StrixOrchestrationHooks()-- class _BrokenBus:- async def record_usage(self, *_: Any, **__: Any) -> None:- raise RuntimeError("simulated")-- ctx = _Ctx(context={"bus": _BrokenBus(), "agent_id": "a1"})-- class _Resp:- usage = None-- # Should not raise.- await hooks.on_llm_end(ctx, agent=None, response=_Resp())diff --git a/tests/runtime/__init__.py b/tests/runtime/__init__.pydeleted file mode 100644index 684b21b9..00000000--- a/tests/runtime/__init__.py+++ /dev/null@@ -1 +0,0 @@-"""Tests for strix.runtime module."""diff --git a/tests/runtime/test_strix_docker_client.py b/tests/runtime/test_strix_docker_client.pydeleted file mode 100644index d65e1d0a..00000000--- a/tests/runtime/test_strix_docker_client.py+++ /dev/null@@ -1,103 +0,0 @@-"""Phase 0 smoke tests for StrixDockerSandboxClient.--These tests do NOT require Docker. They mock the Docker SDK client (passed-to the constructor) and verify our subclass injects the right kwargs into-``containers.create``. Live container tests are part of Phase 0 manual-smoke (TESTING_STRATEGY.md §9).-"""--from __future__ import annotations--import asyncio-from typing import Any-from unittest.mock import MagicMock--import docker.errors # type: ignore[import-untyped,unused-ignore]-import pytest--from strix.runtime.strix_docker_client import StrixDockerSandboxClient---def fake_docker() -> MagicMock:- """Stand-in for the Docker SDK client passed to the subclass."""- fake = MagicMock()- fake.images.get.return_value = MagicMock() # image_exists -> True- fake.images.pull = MagicMock()- fake.containers.create.return_value = MagicMock(name="container")- return fake---def _create_kwargs(fake: MagicMock) -> dict[str, Any]:- result: dict[str, Any] = fake.containers.create.call_args.kwargs- return result---def test_subclass_injects_net_admin_and_net_raw(fake_docker: MagicMock) -> None:- client = StrixDockerSandboxClient(docker_client=fake_docker)- asyncio.run(- client._create_container("strix-image:latest", manifest=None, exposed_ports=()),- )- kwargs = _create_kwargs(fake_docker)- assert "NET_ADMIN" in kwargs["cap_add"]- assert "NET_RAW" in kwargs["cap_add"]---def test_subclass_injects_host_gateway(fake_docker: MagicMock) -> None:- client = StrixDockerSandboxClient(docker_client=fake_docker)- asyncio.run(- client._create_container("strix-image:latest", manifest=None, exposed_ports=()),- )- kwargs = _create_kwargs(fake_docker)- assert kwargs["extra_hosts"]["host.docker.internal"] == "host-gateway"---def test_subclass_preserves_image_and_command(fake_docker: MagicMock) -> None:- client = StrixDockerSandboxClient(docker_client=fake_docker)- asyncio.run(- client._create_container("custom:tag", manifest=None, exposed_ports=()),- )- kwargs = _create_kwargs(fake_docker)- assert kwargs["image"] == "custom:tag"- assert kwargs["entrypoint"] == ["tail"]- assert kwargs["command"] == ["-f", "/dev/null"]- assert kwargs["detach"] is True---def test_subclass_emits_ports_dict_for_exposed_ports(fake_docker: MagicMock) -> None:- client = StrixDockerSandboxClient(docker_client=fake_docker)- asyncio.run(- client._create_container(- "strix-image:latest",- manifest=None,- exposed_ports=(48081, 48080),- ),- )- kwargs = _create_kwargs(fake_docker)- assert "48081/tcp" in kwargs["ports"]- assert "48080/tcp" in kwargs["ports"]---def test_caps_appended_not_duplicated(fake_docker: MagicMock) -> None:- """Idempotent injection: calling twice doesn't add duplicate caps."""- client = StrixDockerSandboxClient(docker_client=fake_docker)- asyncio.run(- client._create_container("img:latest", manifest=None, exposed_ports=()),- )- kwargs = _create_kwargs(fake_docker)- assert kwargs["cap_add"].count("NET_ADMIN") == 1- assert kwargs["cap_add"].count("NET_RAW") == 1---def test_pulls_image_when_missing(fake_docker: MagicMock) -> None:- """If image_exists returns False on first check, pull is invoked."""- # First call raises ImageNotFound, second succeeds.- fake_docker.images.get.side_effect = [- docker.errors.ImageNotFound("not found"),- MagicMock(),- ]- client = StrixDockerSandboxClient(docker_client=fake_docker)- asyncio.run(- client._create_container("registry.io/strix:tag", manifest=None, exposed_ports=()),- )- fake_docker.images.pull.assert_called_once()diff --git a/tests/sandbox/__init__.py b/tests/sandbox/__init__.pydeleted file mode 100644index e69de29b..00000000diff --git a/tests/sandbox/test_caido_capability.py b/tests/sandbox/test_caido_capability.pydeleted file mode 100644index fb5227e2..00000000--- a/tests/sandbox/test_caido_capability.py+++ /dev/null@@ -1,156 +0,0 @@-"""Phase 4 tests for CaidoCapability.--The capability has three observable behaviors that need parity with the-PLAYBOOK contract:--1. ``process_manifest`` injects http_proxy / https_proxy / ALL_PROXY env- vars into the manifest's ``Environment.value`` dict.-2. ``tools()`` returns the seven Caido SDK function tools we wrapped in- Phase 2.5 — same instances, in the documented order.-3. ``bind`` schedules an aggregated healthcheck task; the orchestration- hook later awaits it on first agent start.--The healthcheck task itself is exercised by the healthcheck unit tests;-here we only verify the wiring (task created, name set, points at the-right ports).-"""--from __future__ import annotations--import asyncio-from unittest.mock import MagicMock, patch--import pytest-from agents.sandbox.entries import LocalDir-from agents.sandbox.manifest import Environment, Manifest--from strix.sandbox.caido_capability import CaidoCapability---def test_capability_type_and_default_state() -> None:- cap = CaidoCapability()- assert cap.type == "caido"- assert cap._healthcheck_task is None- assert cap._tool_server_host_port is None- assert cap._caido_host_port is None---def test_process_manifest_injects_proxy_env_vars(tmp_path: object) -> None:- """Existing env vars must be preserved; proxy keys are added."""- cap = CaidoCapability()- manifest = Manifest(- environment=Environment(- value={"PYTHONUNBUFFERED": "1", "TOOL_SERVER_TOKEN": "abc"},- ),- )- out = cap.process_manifest(manifest)- env = out.environment.value- # Pre-existing entries preserved.- assert env["PYTHONUNBUFFERED"] == "1"- assert env["TOOL_SERVER_TOKEN"] == "abc"- # Proxy entries injected, all pointing at the in-container Caido port.- assert env["http_proxy"] == "http://127.0.0.1:48080"- assert env["https_proxy"] == "http://127.0.0.1:48080"- assert env["ALL_PROXY"] == "http://127.0.0.1:48080"---def test_process_manifest_handles_missing_environment() -> None:- """A manifest without env entries should still get the proxy block."""- cap = CaidoCapability()- # ``LocalDir`` requires a real path on disk; use a temp one to satisfy- # the validator without actually mounting anything.- manifest = Manifest(entries={"src": LocalDir(src="/tmp")})- out = cap.process_manifest(manifest)- env = out.environment.value- assert env["http_proxy"] == "http://127.0.0.1:48080"---def test_tools_returns_seven_caido_tools_in_order() -> None:- cap = CaidoCapability()- names = [t.name for t in cap.tools()]- assert names == [- "list_requests",- "view_request",- "send_request",- "repeat_request",- "scope_rules",- "list_sitemap",- "view_sitemap_entry",- ]---def test_tools_returns_a_fresh_list_per_call() -> None:- """SDK convention — caller may mutate the returned list."""- cap = CaidoCapability()- a = cap.tools()- b = cap.tools()- assert a == b- assert a is not b---async def test_instructions_mentions_caido_and_tools() -> None:- cap = CaidoCapability()- out = await cap.instructions(Manifest())- assert out is not None- assert "<caido_proxy>" in out- # Every tool name appears verbatim so the model knows what's available.- for name in (- "list_requests",- "view_request",- "send_request",- "repeat_request",- "scope_rules",- "list_sitemap",- "view_sitemap_entry",- ):- assert name in out---def test_configure_host_ports_stores_both() -> None:- cap = CaidoCapability()- cap.configure_host_ports(tool_server_host_port=12345, caido_host_port=12346)- assert cap._tool_server_host_port == 12345- assert cap._caido_host_port == 12346---async def test_bind_without_configured_ports_skips_healthcheck() -> None:- """If the session manager forgets to configure ports, bind shouldn't- schedule a probe against ``None`` — it should warn and no-op.- """- cap = CaidoCapability()- fake_session = MagicMock()- cap.bind(fake_session)- assert cap._healthcheck_task is None- assert cap.session is fake_session---async def test_bind_schedules_healthcheck_task_when_ports_configured() -> None:- """The hook chain (StrixOrchestrationHooks.on_agent_start) awaits this- task — it must exist as an asyncio.Task with a useful name.- """- cap = CaidoCapability()- cap.configure_host_ports(tool_server_host_port=54321, caido_host_port=54322)- fake_session = MagicMock()-- # Patch the actual probes so we don't try to connect for real.- async def _fake_probe(*args: object, **kwargs: object) -> None:- return None-- with (- patch(- "strix.sandbox.caido_capability.wait_for_http_ready",- side_effect=_fake_probe,- ),- patch(- "strix.sandbox.caido_capability.wait_for_tcp_ready",- side_effect=_fake_probe,- ),- ):- cap.bind(fake_session)- assert cap._healthcheck_task is not None- assert isinstance(cap._healthcheck_task, asyncio.Task)- assert "caido-healthcheck-54321" in cap._healthcheck_task.get_name()- await cap._healthcheck_task # must complete without errordiff --git a/tests/sandbox/test_healthcheck.py b/tests/sandbox/test_healthcheck.pydeleted file mode 100644index 6ee17340..00000000--- a/tests/sandbox/test_healthcheck.py+++ /dev/null@@ -1,171 +0,0 @@-"""Phase 4 tests for the sandbox port readiness probes.--The two helpers (``wait_for_http_ready`` and ``wait_for_tcp_ready``)-gate session bring-up, so a regression here would mean every fresh-scan hits a connection-refused on its first tool call. Tests cover:--- Happy path returns when the probe succeeds.-- Polling continues across transient failures.-- Timeout raises ``SandboxNotReadyError`` with a useful last-error.-- Real ``asyncio.open_connection`` against a local listener verifies- the TCP probe end-to-end (no mocking — the helper is small enough- that a real socket is the cheaper test).-"""--from __future__ import annotations--import asyncio-import contextlib-from typing import Any-from unittest.mock import AsyncMock, MagicMock, patch--import httpx-import pytest--from strix.sandbox.healthcheck import (- SandboxNotReadyError,- wait_for_http_ready,- wait_for_tcp_ready,-)---# --- HTTP probe -------------------------------------------------------------async def test_wait_for_http_ready_returns_immediately_on_2xx() -> None:- response = MagicMock(spec=httpx.Response)- response.status_code = 200- client = AsyncMock()- client.get = AsyncMock(return_value=response)- client.__aenter__ = AsyncMock(return_value=client)- client.__aexit__ = AsyncMock(return_value=None)-- with patch("strix.sandbox.healthcheck.httpx.AsyncClient", return_value=client):- await wait_for_http_ready("http://localhost:9999/health", timeout=1)-- assert client.get.await_count == 1---async def test_wait_for_http_ready_polls_through_connect_errors() -> None:- """Two connect errors followed by a 200 — the helper should keep going."""- response_ok = MagicMock(spec=httpx.Response)- response_ok.status_code = 200-- side_effects: list[Any] = [- httpx.ConnectError("conn refused"),- httpx.ConnectError("conn refused"),- response_ok,- ]-- client = AsyncMock()- client.get = AsyncMock(side_effect=side_effects)- client.__aenter__ = AsyncMock(return_value=client)- client.__aexit__ = AsyncMock(return_value=None)-- with patch("strix.sandbox.healthcheck.httpx.AsyncClient", return_value=client):- await wait_for_http_ready(- "http://localhost:9999/health",- timeout=5,- poll_interval=0.01,- )- assert client.get.await_count == 3---async def test_wait_for_http_ready_raises_after_timeout() -> None:- client = AsyncMock()- client.get = AsyncMock(side_effect=httpx.ConnectError("nope"))- client.__aenter__ = AsyncMock(return_value=client)- client.__aexit__ = AsyncMock(return_value=None)-- with (- patch(- "strix.sandbox.healthcheck.httpx.AsyncClient",- return_value=client,- ),- pytest.raises(SandboxNotReadyError) as exc_info,- ):- await wait_for_http_ready(- "http://localhost:9999/health",- timeout=0.3,- poll_interval=0.05,- )-- err = str(exc_info.value)- assert "http://localhost:9999/health" in err- assert "ConnectError" in err---async def test_wait_for_http_ready_treats_5xx_as_not_ready() -> None:- response_500 = MagicMock(spec=httpx.Response)- response_500.status_code = 500- response_ok = MagicMock(spec=httpx.Response)- response_ok.status_code = 200-- client = AsyncMock()- client.get = AsyncMock(side_effect=[response_500, response_ok])- client.__aenter__ = AsyncMock(return_value=client)- client.__aexit__ = AsyncMock(return_value=None)-- with patch("strix.sandbox.healthcheck.httpx.AsyncClient", return_value=client):- await wait_for_http_ready(- "http://localhost:9999/health",- timeout=2,- poll_interval=0.01,- )- assert client.get.await_count == 2---# --- TCP probe --------------------------------------------------------------async def test_wait_for_tcp_ready_against_real_listener() -> None:- """Spin up a local TCP echo server and verify the probe connects."""-- async def _server_handler(- reader: asyncio.StreamReader,- writer: asyncio.StreamWriter,- ) -> None:- # Drain any bytes the test sends, then close.- await reader.read(0)- writer.close()- with contextlib.suppress(OSError):- await writer.wait_closed()-- server = await asyncio.start_server(_server_handler, "127.0.0.1", 0)- port = server.sockets[0].getsockname()[1]- try:- await wait_for_tcp_ready("127.0.0.1", port, timeout=2, poll_interval=0.05)- finally:- server.close()- await server.wait_closed()---async def test_wait_for_tcp_ready_raises_when_port_closed() -> None:- async def _no_handler(- _reader: asyncio.StreamReader,- _writer: asyncio.StreamWriter,- ) -> None:- return-- # Bind and immediately close to claim a definitely-unused port number.- server = await asyncio.start_server(_no_handler, "127.0.0.1", 0)- closed_port = server.sockets[0].getsockname()[1]- server.close()- await server.wait_closed()-- with pytest.raises(SandboxNotReadyError) as exc_info:- await wait_for_tcp_ready(- "127.0.0.1",- closed_port,- timeout=0.3,- poll_interval=0.05,- )-- err = str(exc_info.value)- assert f"127.0.0.1:{closed_port}" in errdiff --git a/tests/sandbox/test_session_manager.py b/tests/sandbox/test_session_manager.pydeleted file mode 100644index bacdbbe2..00000000--- a/tests/sandbox/test_session_manager.py+++ /dev/null@@ -1,206 +0,0 @@-"""Phase 4 tests for the per-scan sandbox session manager.--We don't spin up real Docker here — the ``StrixDockerSandboxClient`` is-patched and we assert on the manifest / options / bundle shape. Goals:--- Cache hit: a second ``create_or_reuse(scan_id, ...)`` returns the same- bundle without calling client.create twice.-- Manifest carries the right env vars (TOOL_SERVER_TOKEN, container ports,- STRIX_SANDBOX_EXECUTION_TIMEOUT, PYTHONUNBUFFERED).-- The Docker client options request both container ports be exposed.-- Capability is configured with the resolved host ports *before* bind,- so its healthcheck task probes the right ones.-- Bundle is cached and surfaces in ``cached_scan_ids``.-- ``cleanup`` cancels the healthcheck task and calls ``client.delete``;- errors during delete are swallowed.-"""--from __future__ import annotations--from collections.abc import Iterator-from typing import Any-from unittest.mock import AsyncMock, MagicMock, patch--import pytest--from strix.sandbox import session_manager-from strix.sandbox.caido_capability import CaidoCapability--[email protected](autouse=True)-def _isolate_cache() -> Iterator[None]:- session_manager._reset_cache_for_tests()- yield- session_manager._reset_cache_for_tests()---def _noop_bind(_self: Any, _session: Any) -> None:- """Stand-in for CaidoCapability.bind that skips the healthcheck task."""---def _make_endpoint(port: int) -> Any:- ep = MagicMock()- ep.port = port- ep.host = "127.0.0.1"- ep.tls = False- return ep---def _make_client_and_session(- *,- tool_port: int = 12001,- caido_port: int = 12002,-) -> tuple[Any, Any]:- """Build a fake DockerSandboxClient and session pair."""- session = MagicMock()- session._resolve_exposed_port = AsyncMock(- side_effect=lambda port: _make_endpoint(- tool_port if port == 48081 else caido_port,- ),- )- client = MagicMock()- client.create = AsyncMock(return_value=session)- client.delete = AsyncMock()- return client, session---async def test_create_or_reuse_creates_new_session(tmp_path: Any) -> None:- client, session = _make_client_and_session()- # Patch the capability's bind to a no-op so we don't spin up the- # healthcheck task in unit tests.- with (- patch(- "strix.sandbox.session_manager.StrixDockerSandboxClient",- return_value=client,- ),- patch.object(CaidoCapability, "bind", _noop_bind),- ):- bundle = await session_manager.create_or_reuse(- "scan-1",- image="strix-sandbox:test",- sources_path=tmp_path,- )-- # Bundle shape.- assert bundle["client"] is client- assert bundle["session"] is session- assert bundle["tool_server_host_port"] == 12001- assert bundle["caido_host_port"] == 12002- assert isinstance(bundle["bearer"], str) and len(bundle["bearer"]) >= 32- assert isinstance(bundle["capability"], CaidoCapability)- # Capability got the resolved host ports BEFORE bind would have run.- assert bundle["capability"]._tool_server_host_port == 12001- assert bundle["capability"]._caido_host_port == 12002-- # client.create called exactly once with manifest + exposed ports.- assert client.create.await_count == 1- options = client.create.await_args.kwargs["options"]- assert options.image == "strix-sandbox:test"- assert set(options.exposed_ports) == {48080, 48081}-- manifest = client.create.await_args.kwargs["manifest"]- env = manifest.environment.value- assert env["TOOL_SERVER_TOKEN"] == bundle["bearer"]- assert env["TOOL_SERVER_PORT"] == "48081"- assert env["CAIDO_PORT"] == "48080"- assert env["STRIX_SANDBOX_EXECUTION_TIMEOUT"] == "120"- assert env["PYTHONUNBUFFERED"] == "1"- assert env["HOST_GATEWAY"] == "host.docker.internal"---async def test_create_or_reuse_returns_cached_bundle(tmp_path: Any) -> None:- client, _ = _make_client_and_session()- with (- patch(- "strix.sandbox.session_manager.StrixDockerSandboxClient",- return_value=client,- ),- patch.object(CaidoCapability, "bind", _noop_bind),- ):- first = await session_manager.create_or_reuse(- "scan-X",- image="i",- sources_path=tmp_path,- )- second = await session_manager.create_or_reuse(- "scan-X",- image="i",- sources_path=tmp_path,- )-- assert first is second- assert client.create.await_count == 1- assert "scan-X" in session_manager.cached_scan_ids()---async def test_create_or_reuse_passes_custom_execution_timeout(tmp_path: Any) -> None:- client, _ = _make_client_and_session()- with (- patch(- "strix.sandbox.session_manager.StrixDockerSandboxClient",- return_value=client,- ),- patch.object(CaidoCapability, "bind", _noop_bind),- ):- await session_manager.create_or_reuse(- "scan-2",- image="i",- sources_path=tmp_path,- execution_timeout=300,- )-- manifest = client.create.await_args.kwargs["manifest"]- assert manifest.environment.value["STRIX_SANDBOX_EXECUTION_TIMEOUT"] == "300"---async def test_cleanup_calls_delete_and_drops_cache(tmp_path: Any) -> None:- client, session = _make_client_and_session()- with (- patch(- "strix.sandbox.session_manager.StrixDockerSandboxClient",- return_value=client,- ),- patch.object(CaidoCapability, "bind", _noop_bind),- ):- await session_manager.create_or_reuse(- "scan-3",- image="i",- sources_path=tmp_path,- )- assert "scan-3" in session_manager.cached_scan_ids()- await session_manager.cleanup("scan-3")-- client.delete.assert_awaited_once_with(session)- assert "scan-3" not in session_manager.cached_scan_ids()---async def test_cleanup_swallows_delete_errors(tmp_path: Any) -> None:- """A flaky Docker daemon shouldn't prevent cache eviction."""- client, _ = _make_client_and_session()- client.delete = AsyncMock(side_effect=RuntimeError("docker daemon went away"))- with (- patch(- "strix.sandbox.session_manager.StrixDockerSandboxClient",- return_value=client,- ),- patch.object(CaidoCapability, "bind", _noop_bind),- ):- await session_manager.create_or_reuse(- "scan-4",- image="i",- sources_path=tmp_path,- )- await session_manager.cleanup("scan-4") # must not raise-- assert "scan-4" not in session_manager.cached_scan_ids()---async def test_cleanup_unknown_scan_is_noop() -> None:- """No cached entry → cleanup is a quiet no-op."""- await session_manager.cleanup("never-existed") # must not raisediff --git a/tests/skills/__init__.py b/tests/skills/__init__.pydeleted file mode 100644index f0b70da4..00000000--- a/tests/skills/__init__.py+++ /dev/null@@ -1 +0,0 @@-# Tests for skill-related runtime behavior.diff --git a/tests/static/__init__.py b/tests/static/__init__.pydeleted file mode 100644index e69de29b..00000000diff --git a/tests/telemetry/__init__.py b/tests/telemetry/__init__.pydeleted file mode 100644index 8f6aa4f8..00000000--- a/tests/telemetry/__init__.py+++ /dev/null@@ -1 +0,0 @@-"""Tests for strix.telemetry module."""diff --git a/tests/telemetry/test_flags.py b/tests/telemetry/test_flags.pydeleted file mode 100644index a7f8e435..00000000--- a/tests/telemetry/test_flags.py+++ /dev/null@@ -1,28 +0,0 @@-from strix.telemetry.flags import is_otel_enabled, is_posthog_enabled---def test_flags_fallback_to_strix_telemetry(monkeypatch) -> None:- monkeypatch.delenv("STRIX_OTEL_TELEMETRY", raising=False)- monkeypatch.delenv("STRIX_POSTHOG_TELEMETRY", raising=False)- monkeypatch.setenv("STRIX_TELEMETRY", "0")-- assert is_otel_enabled() is False- assert is_posthog_enabled() is False---def test_otel_flag_overrides_global_telemetry(monkeypatch) -> None:- monkeypatch.setenv("STRIX_TELEMETRY", "0")- monkeypatch.setenv("STRIX_OTEL_TELEMETRY", "1")- monkeypatch.delenv("STRIX_POSTHOG_TELEMETRY", raising=False)-- assert is_otel_enabled() is True- assert is_posthog_enabled() is False---def test_posthog_flag_overrides_global_telemetry(monkeypatch) -> None:- monkeypatch.setenv("STRIX_TELEMETRY", "0")- monkeypatch.setenv("STRIX_POSTHOG_TELEMETRY", "1")- monkeypatch.delenv("STRIX_OTEL_TELEMETRY", raising=False)-- assert is_otel_enabled() is False- assert is_posthog_enabled() is Truediff --git a/tests/telemetry/test_strix_processor.py b/tests/telemetry/test_strix_processor.pydeleted file mode 100644index e4a657e8..00000000--- a/tests/telemetry/test_strix_processor.py+++ /dev/null@@ -1,201 +0,0 @@-"""Phase 1 smoke tests for StrixTracingProcessor."""--from __future__ import annotations--import json-import threading-from dataclasses import dataclass, field-from pathlib import Path-from typing import Any--import pytest--from strix.telemetry.strix_processor import StrixTracingProcessor---@dataclass-class _FakeSpanData:- """Minimal stand-in for an SDK SpanData class."""-- name: str = "FunctionSpanData" # used by class .__name__- payload: dict[str, Any] = field(default_factory=dict)-- def export(self) -> dict[str, Any]:- return dict(self.payload)---# Concrete SpanData subclasses so the processor's ``_span_kind`` heuristic-# (drop ``SpanData`` suffix, lowercase) produces stable event_types.-class FunctionSpanData(_FakeSpanData):- pass---class GenerationSpanData(_FakeSpanData):- pass---class AgentSpanData(_FakeSpanData):- pass---@dataclass-class _FakeSpan:- span_id: str- trace_id: str- span_data: _FakeSpanData---@dataclass-class _FakeTrace:- trace_id: str- name: str = "test-workflow"- metadata: dict[str, Any] = field(default_factory=dict)-- def export(self) -> dict[str, Any]:- return {"name": self.name, "metadata": self.metadata}---def _read_events(path: Path) -> list[dict[str, Any]]:- return [json.loads(line) for line in path.read_text().splitlines() if line.strip()]---def run_dir(tmp_path: Path) -> Path:- return tmp_path / "strix_runs" / "test-run"---def test_constructor_creates_run_dir(run_dir: Path) -> None:- StrixTracingProcessor(run_dir=run_dir)- assert run_dir.exists()---def test_on_trace_start_writes_run_started(run_dir: Path) -> None:- p = StrixTracingProcessor(run_dir=run_dir)- p.on_trace_start(_FakeTrace(trace_id="t-1", metadata={"scan_id": "abc"}))-- events = _read_events(p.events_path)- assert events == [- {- "event_type": "run.started",- "trace_id": "t-1",- "metadata": {"name": "test-workflow", "metadata": {"scan_id": "abc"}},- }- ]---def test_on_trace_end_writes_run_completed(run_dir: Path) -> None:- p = StrixTracingProcessor(run_dir=run_dir)- p.on_trace_end(_FakeTrace(trace_id="t-1"))-- events = _read_events(p.events_path)- assert events == [{"event_type": "run.completed", "trace_id": "t-1"}]---def test_span_start_and_end_emit_typed_events(run_dir: Path) -> None:- """``GenerationSpanData`` → ``generation.started`` / ``generation.completed``."""- p = StrixTracingProcessor(run_dir=run_dir)- span = _FakeSpan(- span_id="s-1",- trace_id="t-1",- span_data=GenerationSpanData(payload={"model": "gpt-foo"}),- )-- p.on_span_start(span)- p.on_span_end(span)-- events = _read_events(p.events_path)- assert [e["event_type"] for e in events] == [- "generation.started",- "generation.completed",- ]- assert events[0]["span_id"] == "s-1"- assert events[0]["data"] == {"model": "gpt-foo"}---def test_concurrent_writes_yield_valid_jsonl(run_dir: Path) -> None:- """C7 (AUDIT_R2): per-path lock prevents JSONL corruption under contention."""- p = StrixTracingProcessor(run_dir=run_dir)-- def writer(idx: int) -> None:- for i in range(50):- p._emit({"event_type": "synthetic", "writer": idx, "i": i})-- threads = [threading.Thread(target=writer, args=(i,)) for i in range(10)]- for t in threads:- t.start()- for t in threads:- t.join()-- # 10 threads x 50 events = 500 lines; all valid JSON.- lines = p.events_path.read_text().splitlines()- assert len(lines) == 500- for line in lines:- json.loads(line) # raises on corrupt line---def test_emit_swallows_oserror_and_logs(- run_dir: Path,- caplog: pytest.LogCaptureFixture,-) -> None:- """C16 (AUDIT_R3): a write failure must NOT propagate."""- p = StrixTracingProcessor(run_dir=run_dir)- # Make events_path point to a directory so open(..., "a") raises.- p.events_path = run_dir-- with caplog.at_level("ERROR", logger="strix.telemetry.strix_processor"):- p._emit({"event_type": "boom"})-- assert any("Failed to append" in rec.message for rec in caplog.records)---def test_span_export_failure_does_not_propagate(run_dir: Path) -> None:- """If span_data.export raises, we still emit an event with data=None."""- p = StrixTracingProcessor(run_dir=run_dir)-- class _BoomSpanData:- def export(self) -> dict[str, Any]:- raise RuntimeError("nope")-- # Reuse the lowercase rule: class name has no "SpanData" suffix → "boomspandata"- # would not be ideal; use a properly-named subclass.- class FunctionSpanDataBroken(_BoomSpanData):- pass-- span = _FakeSpan(span_id="s-1", trace_id="t-1", span_data=FunctionSpanDataBroken())- p.on_span_end(span)-- events = _read_events(p.events_path)- assert len(events) == 1- assert events[0]["data"] is None---def test_pii_scrubbed_via_sanitizer(run_dir: Path) -> None:- """Sanitizer is invoked on every emit before write."""- seen: list[Any] = []-- class _StubSanitizer:- def sanitize(self, data: Any, key_hint: str | None = None) -> Any:- seen.append(data)- # Replace any "secret" string with [REDACTED].- if isinstance(data, dict):- clean = {k: "[REDACTED]" if k == "api_key" else v for k, v in data.items()}- if "metadata" in clean and isinstance(clean["metadata"], dict):- md = dict(clean["metadata"])- md.pop("api_key", None)- clean["metadata"] = md- return clean- return data-- p = StrixTracingProcessor(run_dir=run_dir, sanitizer=_StubSanitizer())- p._emit({"event_type": "test", "api_key": "sk-very-secret"})-- events = _read_events(p.events_path)- assert events[0]["api_key"] == "[REDACTED]"- assert seen and seen[0]["api_key"] == "sk-very-secret"---def test_force_flush_and_shutdown_are_noops(run_dir: Path) -> None:- p = StrixTracingProcessor(run_dir=run_dir)- # Should not raise.- p.force_flush()- p.shutdown()diff --git a/tests/telemetry/test_tracer.py b/tests/telemetry/test_tracer.pydeleted file mode 100644index 96dff631..00000000--- a/tests/telemetry/test_tracer.py+++ /dev/null@@ -1,428 +0,0 @@-import json-import sys-import types-from pathlib import Path-from typing import Any, ClassVar--import pytest-from opentelemetry.sdk.trace.export import SimpleSpanProcessor, SpanExportResult--from strix.telemetry import tracer as tracer_module-from strix.telemetry import utils as telemetry_utils-from strix.telemetry.tracer import Tracer, set_global_tracer---def _load_events(events_path: Path) -> list[dict[str, Any]]:- lines = events_path.read_text(encoding="utf-8").splitlines()- return [json.loads(line) for line in lines if line]--[email protected](autouse=True)-def _reset_tracer_globals(monkeypatch: pytest.MonkeyPatch) -> None:- monkeypatch.setattr(tracer_module, "_global_tracer", None)- monkeypatch.setattr(tracer_module, "_OTEL_BOOTSTRAPPED", False)- monkeypatch.setattr(tracer_module, "_OTEL_REMOTE_ENABLED", False)- telemetry_utils.reset_events_write_locks()- monkeypatch.delenv("STRIX_TELEMETRY", raising=False)- monkeypatch.delenv("STRIX_OTEL_TELEMETRY", raising=False)- monkeypatch.delenv("STRIX_POSTHOG_TELEMETRY", raising=False)- monkeypatch.delenv("TRACELOOP_BASE_URL", raising=False)- monkeypatch.delenv("TRACELOOP_API_KEY", raising=False)- monkeypatch.delenv("TRACELOOP_HEADERS", raising=False)---def test_tracer_local_mode_writes_jsonl_with_correlation(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)-- tracer = Tracer("local-observability")- set_global_tracer(tracer)- tracer.set_scan_config({"targets": ["https://example.com"], "user_instructions": "focus auth"})- tracer.log_chat_message("starting scan", "user", "agent-1")- tracer.log_chat_message("scanning login form", "assistant", "agent-1")-- events_path = tmp_path / "strix_runs" / "local-observability" / "events.jsonl"- assert events_path.exists()-- events = _load_events(events_path)- assert any(event["event_type"] == "chat.message" for event in events)- assert any(event["event_type"] == "run.configured" for event in events)-- for event in events:- assert event["run_id"] == "local-observability"- assert event["trace_id"]- assert event["span_id"]---def test_tracer_redacts_sensitive_payloads(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:- monkeypatch.chdir(tmp_path)-- tracer = Tracer("redaction-run")- set_global_tracer(tracer)- tracer.log_chat_message(- "request failed with token sk-secret-token-value",- "assistant",- "agent-1",- metadata={- "api_key": "sk-secret-token-value",- "authorization": "Bearer super-secret-token",- },- )-- events_path = tmp_path / "strix_runs" / "redaction-run" / "events.jsonl"- events = _load_events(events_path)- serialized = json.dumps(events)-- assert "sk-secret-token-value" not in serialized- assert "super-secret-token" not in serialized- assert "[REDACTED]" in serialized---def test_tracer_remote_mode_configures_traceloop_export(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)-- class FakeTraceloop:- init_calls: ClassVar[list[dict[str, Any]]] = []-- @staticmethod- def init(**kwargs: Any) -> None:- FakeTraceloop.init_calls.append(kwargs)-- @staticmethod- def set_association_properties(properties: dict[str, Any]) -> None: # noqa: ARG004- return None-- monkeypatch.setattr(tracer_module, "Traceloop", FakeTraceloop)- monkeypatch.setenv("TRACELOOP_BASE_URL", "https://otel.example.com")- monkeypatch.setenv("TRACELOOP_API_KEY", "test-api-key")- monkeypatch.setenv("TRACELOOP_HEADERS", '{"x-custom":"header"}')-- tracer = Tracer("remote-observability")- set_global_tracer(tracer)- tracer.log_chat_message("hello", "user", "agent-1")-- assert tracer._remote_export_enabled is True- assert FakeTraceloop.init_calls- init_kwargs = FakeTraceloop.init_calls[-1]- assert init_kwargs["api_endpoint"] == "https://otel.example.com"- assert init_kwargs["api_key"] == "test-api-key"- assert init_kwargs["headers"] == {"x-custom": "header"}- assert isinstance(init_kwargs["processor"], SimpleSpanProcessor)- assert "strix.run_id" not in init_kwargs["resource_attributes"]- assert "strix.run_name" not in init_kwargs["resource_attributes"]-- events_path = tmp_path / "strix_runs" / "remote-observability" / "events.jsonl"- events = _load_events(events_path)- run_started = next(event for event in events if event["event_type"] == "run.started")- assert run_started["payload"]["remote_export_enabled"] is True---def test_tracer_local_mode_avoids_traceloop_remote_endpoint(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)-- class FakeTraceloop:- init_calls: ClassVar[list[dict[str, Any]]] = []-- @staticmethod- def init(**kwargs: Any) -> None:- FakeTraceloop.init_calls.append(kwargs)-- @staticmethod- def set_association_properties(properties: dict[str, Any]) -> None: # noqa: ARG004- return None-- monkeypatch.setattr(tracer_module, "Traceloop", FakeTraceloop)-- tracer = Tracer("local-traceloop")- set_global_tracer(tracer)- tracer.log_chat_message("hello", "user", "agent-1")-- assert FakeTraceloop.init_calls- init_kwargs = FakeTraceloop.init_calls[-1]- assert "api_endpoint" not in init_kwargs- assert "api_key" not in init_kwargs- assert "headers" not in init_kwargs- assert isinstance(init_kwargs["processor"], SimpleSpanProcessor)- assert tracer._remote_export_enabled is False---def test_otlp_fallback_includes_auth_and_custom_headers(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)- monkeypatch.setattr(tracer_module, "Traceloop", None)- monkeypatch.setenv("TRACELOOP_BASE_URL", "https://otel.example.com")- monkeypatch.setenv("TRACELOOP_API_KEY", "test-api-key")- monkeypatch.setenv("TRACELOOP_HEADERS", '{"x-custom":"header"}')-- captured: dict[str, Any] = {}-- class FakeOTLPSpanExporter:- def __init__(self, endpoint: str, headers: dict[str, str] | None = None, **kwargs: Any):- captured["endpoint"] = endpoint- captured["headers"] = headers or {}- captured["kwargs"] = kwargs-- def export(self, spans: Any) -> SpanExportResult:- return SpanExportResult.SUCCESS-- def shutdown(self) -> None:- return None-- def force_flush(self, timeout_millis: int = 30_000) -> bool:- return True-- fake_module = types.ModuleType("opentelemetry.exporter.otlp.proto.http.trace_exporter")- fake_module.OTLPSpanExporter = FakeOTLPSpanExporter- monkeypatch.setitem(- sys.modules,- "opentelemetry.exporter.otlp.proto.http.trace_exporter",- fake_module,- )-- tracer = Tracer("otlp-fallback")- set_global_tracer(tracer)-- assert tracer._remote_export_enabled is True- assert captured["endpoint"] == "https://otel.example.com/v1/traces"- assert captured["headers"]["Authorization"] == "Bearer test-api-key"- assert captured["headers"]["x-custom"] == "header"---def test_traceloop_init_failure_does_not_mark_bootstrapped_on_provider_failure(- monkeypatch: pytest.MonkeyPatch,- tmp_path: Path,-) -> None:- monkeypatch.chdir(tmp_path)-- class FakeTraceloop:- @staticmethod- def init(**kwargs: Any) -> None: # noqa: ARG004- raise RuntimeError("traceloop init failed")-- @staticmethod- def set_association_properties(properties: dict[str, Any]) -> None: # noqa: ARG004- return None-- monkeypatch.setattr(tracer_module, "Traceloop", FakeTraceloop)-- def _raise_provider_error(provider: Any) -> None:- raise RuntimeError("provider setup failed")-- monkeypatch.setattr(tracer_module.trace, "set_tracer_provider", _raise_provider_error)-- tracer = Tracer("bootstrap-failure")- set_global_tracer(tracer)-- assert tracer_module._OTEL_BOOTSTRAPPED is False- assert tracer._remote_export_enabled is False---def test_run_completed_event_emitted_once(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:- monkeypatch.chdir(tmp_path)-- tracer = Tracer("single-complete")- set_global_tracer(tracer)- tracer.save_run_data(mark_complete=True)- tracer.save_run_data(mark_complete=True)-- events_path = tmp_path / "strix_runs" / "single-complete" / "events.jsonl"- events = _load_events(events_path)- run_completed = [event for event in events if event["event_type"] == "run.completed"]- assert len(run_completed) == 1---def test_events_with_agent_id_include_agent_name(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)-- tracer = Tracer("agent-name-enrichment")- set_global_tracer(tracer)- # _enrich_actor pulls names from the tracer's agents dict; populate it- # the same way the orchestration path will once wired (placeholder- # until live wiring lands).- tracer.agents["agent-1"] = {"name": "Root Agent"}- tracer.log_chat_message("hello", "assistant", "agent-1")-- events_path = tmp_path / "strix_runs" / "agent-name-enrichment" / "events.jsonl"- events = _load_events(events_path)- chat_event = next(event for event in events if event["event_type"] == "chat.message")-- assert chat_event["actor"]["agent_id"] == "agent-1"- assert chat_event["actor"]["agent_name"] == "Root Agent"---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)-- tracer.record_llm_usage(- input_tokens=1_000,- output_tokens=250,- cached_tokens=100,- cost=0.12345,- requests=2,- )- tracer.record_llm_usage(- input_tokens=2_000,- output_tokens=500,- cached_tokens=400,- cost=0.54321,- requests=3,- )-- stats = tracer.get_total_llm_stats()-- assert stats["total"] == {- "input_tokens": 3_000,- "output_tokens": 750,- "cached_tokens": 500,- "cost": 0.6667,- "requests": 5,- }- assert stats["total_tokens"] == 3_750---def test_run_metadata_is_only_on_run_lifecycle_events(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)-- tracer = Tracer("metadata-scope")- set_global_tracer(tracer)- tracer.log_chat_message("hello", "assistant", "agent-1")- tracer.save_run_data(mark_complete=True)-- events_path = tmp_path / "strix_runs" / "metadata-scope" / "events.jsonl"- events = _load_events(events_path)-- run_started = next(event for event in events if event["event_type"] == "run.started")- run_completed = next(event for event in events if event["event_type"] == "run.completed")- chat_event = next(event for event in events if event["event_type"] == "chat.message")-- assert "run_metadata" in run_started- assert "run_metadata" in run_completed- assert "run_metadata" not in chat_event---def test_set_run_name_resets_cached_paths(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:- monkeypatch.chdir(tmp_path)-- tracer = Tracer()- set_global_tracer(tracer)- old_events_path = tracer.events_file_path-- tracer.set_run_name("renamed-run")- tracer.log_chat_message("hello", "assistant", "agent-1")-- new_events_path = tracer.events_file_path- assert new_events_path != old_events_path- assert new_events_path == tmp_path / "strix_runs" / "renamed-run" / "events.jsonl"-- events = _load_events(new_events_path)- assert any(event["event_type"] == "run.started" for event in events)- assert any(event["event_type"] == "chat.message" for event in events)---def test_set_run_name_resets_run_completed_flag(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)-- tracer = Tracer()- set_global_tracer(tracer)-- tracer.save_run_data(mark_complete=True)- tracer.set_run_name("renamed-complete")- tracer.save_run_data(mark_complete=True)-- events_path = tmp_path / "strix_runs" / "renamed-complete" / "events.jsonl"- events = _load_events(events_path)- run_completed = [event for event in events if event["event_type"] == "run.completed"]-- assert any(event["event_type"] == "run.started" for event in events)- assert len(run_completed) == 1---def test_set_run_name_updates_traceloop_association_properties(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)-- class FakeTraceloop:- associations: ClassVar[list[dict[str, Any]]] = []-- @staticmethod- def init(**kwargs: Any) -> None: # noqa: ARG004- return None-- @staticmethod- def set_association_properties(properties: dict[str, Any]) -> None:- FakeTraceloop.associations.append(properties)-- monkeypatch.setattr(tracer_module, "Traceloop", FakeTraceloop)-- tracer = Tracer()- set_global_tracer(tracer)- tracer.set_run_name("renamed-run")-- assert FakeTraceloop.associations- assert FakeTraceloop.associations[-1]["run_id"] == "renamed-run"- assert FakeTraceloop.associations[-1]["run_name"] == "renamed-run"---def test_events_write_locks_are_scoped_by_events_file(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)- monkeypatch.setenv("STRIX_TELEMETRY", "0")-- tracer_one = Tracer("lock-run-a")- tracer_two = Tracer("lock-run-b")-- lock_a_from_one = tracer_one._get_events_write_lock(tracer_one.events_file_path)- lock_a_from_two = tracer_two._get_events_write_lock(tracer_one.events_file_path)- lock_b = tracer_two._get_events_write_lock(tracer_two.events_file_path)-- assert lock_a_from_one is lock_a_from_two- assert lock_a_from_one is not lock_b---def test_tracer_skips_jsonl_when_telemetry_disabled(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)- monkeypatch.setenv("STRIX_TELEMETRY", "0")-- tracer = Tracer("telemetry-disabled")- set_global_tracer(tracer)- tracer.log_chat_message("hello", "assistant", "agent-1")- tracer.save_run_data(mark_complete=True)-- events_path = tmp_path / "strix_runs" / "telemetry-disabled" / "events.jsonl"- assert not events_path.exists()---def test_tracer_otel_flag_overrides_global_telemetry(- monkeypatch: pytest.MonkeyPatch, tmp_path: Path-) -> None:- monkeypatch.chdir(tmp_path)- monkeypatch.setenv("STRIX_TELEMETRY", "0")- monkeypatch.setenv("STRIX_OTEL_TELEMETRY", "1")-- tracer = Tracer("otel-enabled")- set_global_tracer(tracer)- tracer.log_chat_message("hello", "assistant", "agent-1")- tracer.save_run_data(mark_complete=True)-- events_path = tmp_path / "strix_runs" / "otel-enabled" / "events.jsonl"- assert events_path.exists()diff --git a/tests/telemetry/test_utils.py b/tests/telemetry/test_utils.pydeleted file mode 100644index 3e039ac6..00000000--- a/tests/telemetry/test_utils.py+++ /dev/null@@ -1,39 +0,0 @@-from strix.telemetry.utils import prune_otel_span_attributes---def test_prune_otel_span_attributes_drops_high_volume_prompt_content() -> None:- attributes = {- "gen_ai.operation.name": "openai.chat",- "gen_ai.request.model": "gpt-5.2",- "gen_ai.prompt.0.role": "system",- "gen_ai.prompt.0.content": "a" * 20_000,- "gen_ai.completion.0.content": "b" * 10_000,- "llm.input_messages.0.content": "c" * 5_000,- "llm.output_messages.0.content": "d" * 5_000,- "llm.input": "x" * 3_000,- "llm.output": "y" * 3_000,- }-- pruned = prune_otel_span_attributes(attributes)-- assert "gen_ai.prompt.0.content" not in pruned- assert "gen_ai.completion.0.content" not in pruned- assert "llm.input_messages.0.content" not in pruned- assert "llm.output_messages.0.content" not in pruned- assert "llm.input" not in pruned- assert "llm.output" not in pruned- assert pruned["gen_ai.operation.name"] == "openai.chat"- assert pruned["gen_ai.prompt.0.role"] == "system"- assert pruned["strix.filtered_attributes_count"] == 6---def test_prune_otel_span_attributes_keeps_metadata_when_nothing_is_dropped() -> None:- attributes = {- "gen_ai.operation.name": "openai.chat",- "gen_ai.request.model": "gpt-5.2",- "gen_ai.prompt.0.role": "user",- }-- pruned = prune_otel_span_attributes(attributes)-- assert pruned == attributesdiff --git a/tests/test_entry.py b/tests/test_entry.pydeleted file mode 100644index 999862ab..00000000--- a/tests/test_entry.py+++ /dev/null@@ -1,319 +0,0 @@-"""Phase 5 tests for the top-level SDK scan entry point.--We never spin up a real Docker container or hit a real LLM here. The-tests patch ``session_manager.create_or_reuse``, ``Runner.run``, and-the agent factory so we can verify the wiring shape:--- The bus is registered with a root agent before Runner.run.-- The context dict carries every field downstream code (tools, hooks,- filter) reads.-- The session manager's bundle flows through to the context (host- ports, bearer, sandbox session/client).-- ``cleanup_on_exit=True`` always cleans up, even when Runner.run- raises.-- ``cleanup_on_exit=False`` preserves the cached session.-- Cancellation propagates: if Runner.run raises, descendants are- cancelled before re-raising.-"""--from __future__ import annotations--from pathlib import Path-from typing import Any-from unittest.mock import AsyncMock, MagicMock, patch--import pytest--from strix.entry import _build_root_task, _build_scope_context, run_strix_scan-from strix.orchestration.bus import AgentMessageBus---# --- helpers ---------------------------------------------------------------def _bundle_for_test() -> dict[str, Any]:- return {- "client": MagicMock(name="docker_client"),- "session": MagicMock(name="sandbox_session"),- "capability": MagicMock(),- "tool_server_host_port": 12001,- "caido_host_port": 12002,- "bearer": "test-bearer-token-1234567890",- }---def _scan_config(**overrides: Any) -> dict[str, Any]:- base: dict[str, Any] = {- "targets": [- {- "type": "web_application",- "details": {"target_url": "https://example.com"},- },- ],- "user_instructions": "find xss",- "scan_mode": "deep",- "is_whitebox": False,- }- base.update(overrides)- return base---# --- task / scope builders ------------------------------------------------def test_build_root_task_groups_targets_and_appends_instructions() -> None:- config = _scan_config(- targets=[- {- "type": "repository",- "details": {- "target_repo": "https://github.com/x/y",- "cloned_repo_path": "/tmp/y",- "workspace_subdir": "y",- },- },- {- "type": "ip_address",- "details": {"target_ip": "10.0.0.1"},- },- ],- user_instructions="report only critical issues",- )- task = _build_root_task(config)- assert "Repositories:" in task- assert "https://github.com/x/y (available at: /workspace/y)" in task- assert "IP Addresses:" in task- assert "10.0.0.1" in task- assert "Special instructions: report only critical issues" in task---def test_build_root_task_renders_diff_scope_block() -> None:- config = _scan_config(- diff_scope={- "active": True,- "repos": [- {- "workspace_subdir": "service-x",- "analyzable_files_count": 7,- "deleted_files_count": 2,- },- ],- },- )- task = _build_root_task(config)- assert "Scope Constraints:" in task- assert "service-x: 7 changed file(s)" in task- assert "service-x: 2 deleted file(s)" in task---def test_build_scope_context_marks_authorization_source() -> None:- config = _scan_config(- targets=[- {- "type": "web_application",- "details": {"target_url": "https://target.test"},- },- ],- )- ctx = _build_scope_context(config)- assert ctx["scope_source"] == "system_scan_config"- assert ctx["authorization_source"] == "strix_platform_verified_targets"- assert ctx["user_instructions_do_not_expand_scope"] is True- assert ctx["authorized_targets"] == [- {"type": "web_application", "value": "https://target.test", "workspace_path": ""},- ]---# --- run_strix_scan wiring ------------------------------------------------async def test_run_strix_scan_wires_context_and_calls_runner(tmp_path: Path) -> None:- """End-to-end (mocked) — assert every downstream consumer of context- sees the bundle's bearer + host ports."""- bundle = _bundle_for_test()- captured_context: dict[str, Any] = {}-- async def fake_runner_run(*args: Any, **kwargs: Any) -> Any:- captured_context.update(kwargs.get("context", {}))- return MagicMock(name="run_result")-- with (- patch(- "strix.entry.session_manager.create_or_reuse",- new=AsyncMock(return_value=bundle),- ) as create_mock,- patch(- "strix.entry.session_manager.cleanup",- new=AsyncMock(),- ) as cleanup_mock,- patch("strix.entry.Runner.run", side_effect=fake_runner_run) as runner_mock,- # Stub the factory to avoid rendering the 158k-char prompt for- # every test (it's covered by sdk_prompt tests).- patch(- "strix.entry.build_strix_agent",- return_value=MagicMock(name="root_agent"),- ) as factory_mock,- ):- await run_strix_scan(- scan_config=_scan_config(),- scan_id="scan-test",- image="strix-sandbox:test",- sources_path=tmp_path,- )-- # Session manager calls.- create_mock.assert_awaited_once()- create_args = create_mock.await_args- assert create_args is not None- assert create_args.args == ("scan-test",)- assert create_args.kwargs["image"] == "strix-sandbox:test"- assert create_args.kwargs["sources_path"] == tmp_path- cleanup_mock.assert_awaited_once_with("scan-test")-- # Factory called with is_root=True.- factory_mock.assert_called_once()- assert factory_mock.call_args.kwargs["is_root"] is True-- # Runner.run called once with the root agent.- assert runner_mock.call_count == 1-- # Context shape passed into Runner.run.- assert captured_context["sandbox_session"] is bundle["session"]- assert captured_context["sandbox_client"] is bundle["client"]- assert captured_context["sandbox_token"] == bundle["bearer"]- assert captured_context["tool_server_host_port"] == bundle["tool_server_host_port"]- assert captured_context["caido_host_port"] == bundle["caido_host_port"]- # Bus is registered and root agent_id is populated.- bus = captured_context["bus"]- assert isinstance(bus, AgentMessageBus)- assert captured_context["agent_id"] in bus.statuses- assert bus.parent_of[captured_context["agent_id"]] is None- # Child factory wired through so create_agent works.- assert callable(captured_context["agent_factory"])---async def test_run_strix_scan_cleans_up_on_runner_failure(tmp_path: Path) -> None:- """If Runner.run raises, cleanup must still fire (the finally branch)."""- bundle = _bundle_for_test()-- with (- patch(- "strix.entry.session_manager.create_or_reuse",- new=AsyncMock(return_value=bundle),- ),- patch(- "strix.entry.session_manager.cleanup",- new=AsyncMock(),- ) as cleanup_mock,- patch(- "strix.entry.Runner.run",- side_effect=RuntimeError("simulated LLM blow-up"),- ),- patch("strix.entry.build_strix_agent", return_value=MagicMock()),- pytest.raises(RuntimeError, match="simulated LLM"),- ):- await run_strix_scan(- scan_config=_scan_config(),- scan_id="scan-fail",- image="i",- sources_path=tmp_path,- )-- cleanup_mock.assert_awaited_once_with("scan-fail")---async def test_run_strix_scan_skips_cleanup_when_disabled(tmp_path: Path) -> None:- bundle = _bundle_for_test()-- async def fake_runner_run(*args: Any, **kwargs: Any) -> Any:- return MagicMock()-- with (- patch(- "strix.entry.session_manager.create_or_reuse",- new=AsyncMock(return_value=bundle),- ),- patch(- "strix.entry.session_manager.cleanup",- new=AsyncMock(),- ) as cleanup_mock,- patch("strix.entry.Runner.run", side_effect=fake_runner_run),- patch("strix.entry.build_strix_agent", return_value=MagicMock()),- ):- await run_strix_scan(- scan_config=_scan_config(),- scan_id="scan-keep",- image="i",- sources_path=tmp_path,- cleanup_on_exit=False,- )-- cleanup_mock.assert_not_called()---async def test_run_strix_scan_auto_generates_scan_id(tmp_path: Path) -> None:- """A caller without a stable id should still get a valid scan_id- flowing into create_or_reuse."""- bundle = _bundle_for_test()- captured_scan_id: list[str] = []-- async def fake_create(scan_id: str, **_kwargs: Any) -> Any:- captured_scan_id.append(scan_id)- return bundle-- with (- patch(- "strix.entry.session_manager.create_or_reuse",- new=AsyncMock(side_effect=fake_create),- ),- patch("strix.entry.session_manager.cleanup", new=AsyncMock()),- patch("strix.entry.Runner.run", new=AsyncMock(return_value=MagicMock())),- patch("strix.entry.build_strix_agent", return_value=MagicMock()),- ):- await run_strix_scan(- scan_config=_scan_config(),- image="i",- sources_path=tmp_path,- )-- assert len(captured_scan_id) == 1- assert captured_scan_id[0].startswith("scan-")- assert len(captured_scan_id[0]) > len("scan-")---async def test_run_strix_scan_passes_scan_level_config_into_factory(- tmp_path: Path,-) -> None:- """scan_mode / is_whitebox flow from scan_config into both the- root factory call and the child factory closure."""- bundle = _bundle_for_test()- factory_calls: list[dict[str, Any]] = []-- def fake_factory(**kwargs: Any) -> Any:- factory_calls.append(kwargs)- return MagicMock()-- with (- patch(- "strix.entry.session_manager.create_or_reuse",- new=AsyncMock(return_value=bundle),- ),- patch("strix.entry.session_manager.cleanup", new=AsyncMock()),- patch("strix.entry.Runner.run", new=AsyncMock(return_value=MagicMock())),- patch("strix.entry.build_strix_agent", side_effect=fake_factory),- ):- await run_strix_scan(- scan_config=_scan_config(scan_mode="fast", is_whitebox=True),- scan_id="s",- image="i",- sources_path=tmp_path,- )-- assert factory_calls[0]["scan_mode"] == "fast"- assert factory_calls[0]["is_whitebox"] is True- assert factory_calls[0]["is_root"] is Truediff --git a/tests/test_run_config_factory.py b/tests/test_run_config_factory.pydeleted file mode 100644index 159ea22f..00000000--- a/tests/test_run_config_factory.py+++ /dev/null@@ -1,173 +0,0 @@-"""Smoke tests for make_run_config / make_agent_context."""--from __future__ import annotations--from agents import RunConfig-from agents.model_settings import ModelSettings-from agents.retry import ModelRetryBackoffSettings--from strix.orchestration.bus import AgentMessageBus-from strix.run_config_factory import make_agent_context, make_run_config---def test_make_run_config_returns_run_config() -> None:- cfg = make_run_config(sandbox_session=None)- assert isinstance(cfg, RunConfig)---def test_default_parallel_tool_calls_is_false() -> None:- """Default is sequential — the tool server serializes one task per agent."""- cfg = make_run_config(sandbox_session=None)- assert cfg.model_settings is not None- assert cfg.model_settings.parallel_tool_calls is False---def test_default_tool_choice_is_required() -> None:- cfg = make_run_config(sandbox_session=None)- assert cfg.model_settings is not None- assert cfg.model_settings.tool_choice == "required"---def test_call_model_input_filter_is_wired() -> None:- cfg = make_run_config(sandbox_session=None)- assert cfg.call_model_input_filter is not None- # Wired to inject_messages_filter (validated by name to keep import light).- assert cfg.call_model_input_filter.__name__ == "inject_messages_filter"---def test_retry_settings_have_max_retries_5() -> None:- cfg = make_run_config(sandbox_session=None)- assert cfg.model_settings is not None- retry = cfg.model_settings.retry- assert retry is not None- assert retry.max_retries == 5---def test_retry_backoff_uses_strix_defaults() -> None:- """min(90, 2*2^n) with initial 2s, max 90s, x2."""- cfg = make_run_config(sandbox_session=None)- assert cfg.model_settings is not None- retry = cfg.model_settings.retry- assert retry is not None- backoff = retry.backoff- assert isinstance(backoff, ModelRetryBackoffSettings)- assert backoff.initial_delay == 2.0- assert backoff.max_delay == 90.0- assert backoff.multiplier == 2.0---def test_retry_policy_is_set() -> None:- """Retry policy is wired (auth/validation 4xx excluded by construction)."""- cfg = make_run_config(sandbox_session=None)- assert cfg.model_settings is not None- retry = cfg.model_settings.retry- assert retry is not None- assert retry.policy is not None---def test_trace_include_sensitive_data_is_false() -> None:- cfg = make_run_config(sandbox_session=None)- assert cfg.trace_include_sensitive_data is False---def test_model_settings_override_merges() -> None:- """Per-call override path."""- override = ModelSettings(tool_choice="auto", parallel_tool_calls=True)- cfg = make_run_config(sandbox_session=None, model_settings_override=override)- assert cfg.model_settings is not None- assert cfg.model_settings.tool_choice == "auto"- assert cfg.model_settings.parallel_tool_calls is True- # Retry settings (not in override) preserved from base.- assert cfg.model_settings.retry is not None- assert cfg.model_settings.retry.max_retries == 5---def test_reasoning_effort_propagates() -> None:- cfg = make_run_config(sandbox_session=None, reasoning_effort="high")- assert cfg.model_settings is not None- assert cfg.model_settings.reasoning is not None- assert cfg.model_settings.reasoning.effort == "high"---def test_max_turns_default_is_300() -> None:- """Default max_turns=300 in make_agent_context.-- ``max_turns`` itself is passed to ``Runner.run``; the context copy is- consumed by the budget-warning hook.- """- bus = AgentMessageBus()- ctx = make_agent_context(- bus=bus,- sandbox_session=None,- sandbox_token=None,- tool_server_host_port=None,- caido_host_port=None,- agent_id="root",- parent_id=None,- tracer=None,- )- assert ctx["max_turns"] == 300---def test_make_agent_context_full_shape() -> None:- """The context dict carries every field tools/hooks reach for."""- bus = AgentMessageBus()- ctx = make_agent_context(- bus=bus,- sandbox_session=None,- sandbox_token="bearer-xyz",- tool_server_host_port=48081,- caido_host_port=48080,- agent_id="agent-1",- parent_id=None,- tracer="not-a-real-tracer",- is_whitebox=True,- diff_scope={"changed_files": ["src/app.py"]},- run_id="strix_runs/abc_def",- )-- assert ctx["bus"] is bus- assert ctx["agent_id"] == "agent-1"- assert ctx["parent_id"] is None- assert ctx["agent_finish_called"] is False- assert ctx["turn_count"] == 0- assert ctx["is_whitebox"] is True- assert ctx["diff_scope"] == {"changed_files": ["src/app.py"]}- assert ctx["run_id"] == "strix_runs/abc_def"- assert ctx["sandbox_token"] == "bearer-xyz"- assert ctx["tool_server_host_port"] == 48081- assert ctx["caido_host_port"] == 48080---def test_make_agent_context_is_whitebox_defaults_false() -> None:- bus = AgentMessageBus()- ctx = make_agent_context(- bus=bus,- sandbox_session=None,- sandbox_token=None,- tool_server_host_port=None,- caido_host_port=None,- agent_id="r",- parent_id=None,- tracer=None,- )- assert ctx["is_whitebox"] is False- assert ctx["diff_scope"] is None---def test_sandbox_config_omitted_when_no_session() -> None:- cfg = make_run_config(sandbox_session=None)- assert cfg.sandbox is None---def test_model_default_is_strix_claude() -> None:- cfg = make_run_config(sandbox_session=None)- assert cfg.model == "anthropic/claude-sonnet-4-6"---def test_multi_provider_is_built() -> None:- """Verify the factory wires our custom MultiProvider, not the SDK default."""- cfg = make_run_config(sandbox_session=None)- # MultiProvider is opaque, but our build_multi_provider returns- # an instance with our prefix routes installed.- assert cfg.model_provider is not Nonediff --git a/tests/tools/__init__.py b/tests/tools/__init__.pydeleted file mode 100644index 182b8f12..00000000--- a/tests/tools/__init__.py+++ /dev/null@@ -1 +0,0 @@-"""Tests for strix.tools module."""diff --git a/tests/tools/conftest.py b/tests/tools/conftest.pydeleted file mode 100644index 186c5769..00000000--- a/tests/tools/conftest.py+++ /dev/null@@ -1,34 +0,0 @@-"""Fixtures for strix.tools tests."""--from collections.abc import Callable-from typing import Any--import pytest---def sample_function_with_types() -> Callable[..., None]:- """Create a sample function with type annotations for testing argument conversion."""-- def func(- name: str,- count: int,- enabled: bool,- ratio: float,- items: list[Any],- config: dict[str, Any],- optional: str | None = None,- ) -> None:- pass-- return func---def sample_function_no_annotations() -> Callable[..., None]:- """Create a sample function without type annotations."""-- def func(arg1, arg2, arg3): # type: ignore[no-untyped-def]- pass-- return funcdiff --git a/tests/tools/test_decorator.py b/tests/tools/test_decorator.pydeleted file mode 100644index dc73e342..00000000--- a/tests/tools/test_decorator.py+++ /dev/null@@ -1,73 +0,0 @@-"""Phase 0 smoke tests for the strix_tool decorator factory.--The SDK's ``FunctionTool`` only honors ``timeout_seconds`` for ``async``-handlers (verified at ``agents.tool._validate_function_tool_timeout_config``):-sync function bodies cannot be cleanly cancelled, so the SDK refuses to-attach a timeout to them. Every Strix tool is therefore an ``async def``;-sync libraries (libtmux, IPython) get wrapped in ``asyncio.to_thread``-inside the async tool body.-"""--from __future__ import annotations--import pytest-from agents.tool import FunctionTool--from strix.tools._decorator import strix_tool---def test_strix_tool_returns_function_tool() -> None:- @strix_tool()- async def my_tool(x: int) -> str:- """Do a thing."""- return str(x)-- assert isinstance(my_tool, FunctionTool)---def test_strix_tool_default_timeout_is_120s() -> None:- @strix_tool()- async def my_tool(x: int) -> str:- """Do a thing."""- return str(x)-- assert my_tool.timeout_seconds == 120.0---def test_strix_tool_default_timeout_behavior_is_error_as_result() -> None:- @strix_tool()- async def my_tool(x: int) -> str:- """Do a thing."""- return str(x)-- assert my_tool.timeout_behavior == "error_as_result"---def test_strix_tool_timeout_override() -> None:- @strix_tool(timeout=300)- async def my_tool(x: int) -> str:- """Do a thing."""- return str(x)-- assert my_tool.timeout_seconds == 300.0---def test_strix_tool_critical_tool_can_raise() -> None:- """C20 (AUDIT_R3): critical tools opt into raise_exception."""-- @strix_tool(timeout=30, timeout_behavior="raise_exception")- async def critical_tool(x: int) -> str:- """Do a critical thing."""- return str(x)-- assert critical_tool.timeout_behavior == "raise_exception"---def test_strix_tool_sync_handlers_rejected_by_sdk() -> None:- """SDK explicitly rejects timeout on sync handlers; documenting the constraint."""- with pytest.raises(ValueError, match="async @function_tool"):-- @strix_tool()- def my_sync_tool(x: int) -> str:- """Sync tools can't have a timeout in the SDK."""- return str(x)diff --git a/tests/tools/test_graph_tools.py b/tests/tools/test_graph_tools.pydeleted file mode 100644index bf99e67b..00000000--- a/tests/tools/test_graph_tools.py+++ /dev/null@@ -1,514 +0,0 @@-"""Phase 3 tests for the multi-agent graph SDK tools.--Six tools: view_agent_graph, agent_status, send_message_to_agent,-wait_for_message, create_agent, agent_finish.--Strategy:--- Build a real ``AgentMessageBus`` in each test and put it under- ``ctx.context['bus']`` so the tools exercise the same code path- production runs do.-- ``create_agent`` is the only tool that touches ``Runner.run`` and- ``asyncio.create_task``. Its test injects a stub agent factory and- patches the SDK's ``Runner.run`` to a sentinel coroutine — we verify- the spawn shape (bus.register called, task handle stored, identity- block in initial input) without spinning up a real LLM.-- ``wait_for_message`` is exercised on both branches: a message arrives- mid-poll, and the timeout path.-"""--from __future__ import annotations--import asyncio-import json-from dataclasses import dataclass, field-from typing import Any-from unittest.mock import AsyncMock, patch--import pytest-from agents.tool import FunctionTool--from strix.orchestration.bus import AgentMessageBus-from strix.tools.agents_graph.tools import (- agent_finish,- agent_status,- create_agent,- send_message_to_agent,- view_agent_graph,- wait_for_message,-)---@dataclass-class _Ctx:- context: dict[str, Any] = field(default_factory=dict)---async def _invoke(tool: FunctionTool, ctx: _Ctx, **kwargs: Any) -> dict[str, Any]:- from agents.tool_context import ToolContext-- tool_ctx = ToolContext(- context=ctx.context,- usage=None,- tool_name=tool.name,- tool_call_id="test-call-id",- tool_arguments=json.dumps(kwargs),- )- result = await tool.on_invoke_tool(tool_ctx, json.dumps(kwargs))- assert isinstance(result, str)- decoded = json.loads(result)- assert isinstance(decoded, dict)- return decoded---async def _make_bus_with_agents() -> AgentMessageBus:- """Bus prepopulated with a root + two registered children."""- bus = AgentMessageBus()- await bus.register("root-1", "root", parent_id=None)- await bus.register("child-A", "scanner", parent_id="root-1")- await bus.register("child-B", "exploiter", parent_id="root-1")- return bus---def _ctx_for(bus: AgentMessageBus, agent_id: str = "root-1") -> _Ctx:- return _Ctx(context={"bus": bus, "agent_id": agent_id, "parent_id": None})---# --- registration ------------------------------------------------------------def test_all_graph_tools_are_function_tools() -> None:- for tool in (- view_agent_graph,- agent_status,- send_message_to_agent,- wait_for_message,- create_agent,- agent_finish,- ):- assert isinstance(tool, FunctionTool)---# --- view_agent_graph --------------------------------------------------------async def test_view_agent_graph_renders_tree() -> None:- bus = await _make_bus_with_agents()- out = await _invoke(view_agent_graph, _ctx_for(bus))- assert out["success"] is True- assert "root (root-1)" in out["graph_structure"]- assert "scanner (child-A)" in out["graph_structure"]- assert "exploiter (child-B)" in out["graph_structure"]- # The "you" marker should be on the calling agent's line.- you_lines = [line for line in out["graph_structure"].splitlines() if "← you" in line]- assert len(you_lines) == 1- assert "root-1" in you_lines[0]- assert out["summary"]["total"] == 3- assert out["summary"]["running"] == 3---async def test_view_agent_graph_handles_missing_bus() -> None:- out = await _invoke(view_agent_graph, _Ctx(context={}))- assert out["success"] is False- assert "Bus" in out["error"]---# --- agent_status ------------------------------------------------------------async def test_agent_status_returns_state() -> None:- bus = await _make_bus_with_agents()- out = await _invoke(agent_status, _ctx_for(bus), agent_id="child-A")- assert out["success"] is True- assert out["agent_id"] == "child-A"- assert out["name"] == "scanner"- assert out["status"] == "running"- assert out["parent_id"] == "root-1"- assert out["pending_messages"] == 0---async def test_agent_status_unknown_id() -> None:- bus = await _make_bus_with_agents()- out = await _invoke(agent_status, _ctx_for(bus), agent_id="nope")- assert out["success"] is False- assert "Unknown" in out["error"]---# --- send_message_to_agent --------------------------------------------------async def test_send_message_queues_into_target_inbox() -> None:- bus = await _make_bus_with_agents()- out = await _invoke(- send_message_to_agent,- _ctx_for(bus, agent_id="child-A"),- target_agent_id="child-B",- message="hello sibling",- priority="high",- )- assert out["success"] is True- assert out["delivery_status"] == "queued"- # Drain via the same API the filter uses; confirm the message landed.- msgs = await bus.drain("child-B")- assert len(msgs) == 1- assert msgs[0]["from"] == "child-A"- assert msgs[0]["content"] == "hello sibling"- assert msgs[0]["priority"] == "high"---async def test_send_message_unknown_target() -> None:- bus = await _make_bus_with_agents()- out = await _invoke(- send_message_to_agent,- _ctx_for(bus),- target_agent_id="ghost",- message="hi",- )- assert out["success"] is False- assert "not found" in out["error"]---async def test_send_message_to_finalized_agent_is_rejected() -> None:- """A finalized target should not silently swallow messages."""- bus = await _make_bus_with_agents()- await bus.finalize("child-A", "completed")- out = await _invoke(- send_message_to_agent,- _ctx_for(bus),- target_agent_id="child-A",- message="too late",- )- assert out["success"] is False- # finalize() also clears parent_of/names, so the user-visible state is- # "completed" — confirm the wrapper treats finalized agents as- # undeliverable rather than queuing into a dropped inbox.- assert "completed" in out["error"] or "not found" in out["error"]---# --- wait_for_message -------------------------------------------------------async def test_wait_for_message_returns_when_message_arrives() -> None:- bus = await _make_bus_with_agents()-- async def deliver_after_short_pause() -> None:- await asyncio.sleep(0.1)- await bus.send("child-A", {"from": "child-B", "content": "ping", "type": "info"})-- sender = asyncio.create_task(deliver_after_short_pause())- out = await _invoke(- wait_for_message,- _ctx_for(bus, agent_id="child-A"),- timeout_seconds=3,- )- await sender- assert out["success"] is True- assert out["status"] == "message_arrived"- assert out["pending_messages"] >= 1- # Status must be returned to "running" after the wait completes.- assert bus.statuses["child-A"] == "running"---async def test_wait_for_message_times_out() -> None:- bus = await _make_bus_with_agents()- out = await _invoke(- wait_for_message,- _ctx_for(bus, agent_id="child-A"),- timeout_seconds=1,- )- assert out["success"] is True- assert out["status"] == "timeout"- assert out["timeout_seconds"] == 1- assert bus.statuses["child-A"] == "running"---# --- create_agent -----------------------------------------------------------async def test_create_agent_requires_factory_in_context() -> None:- bus = await _make_bus_with_agents()- out = await _invoke(- create_agent,- _ctx_for(bus),- name="recon-bot",- task="enumerate hosts",- )- assert out["success"] is False- assert "agent_factory" in out["error"]---async def test_create_agent_spawns_and_registers_child() -> None:- """Verify the spawn shape without running a real LLM."""- bus = await _make_bus_with_agents()-- factory_calls: list[dict[str, Any]] = []-- def fake_factory(*, name: str, skills: list[str]) -> Any:- factory_calls.append({"name": name, "skills": list(skills)})- # The Runner.run patch below ignores this object; any sentinel- # works.- return object()-- runner_calls: list[dict[str, Any]] = []-- async def fake_runner_run(*args: Any, **kwargs: Any) -> Any:- # Capture the input + max_turns so the test can assert the- # identity block + delegation envelope are present.- runner_calls.append({"args": args, "kwargs": kwargs})- await asyncio.sleep(0) # cooperate so create_task can return- return None-- ctx = _Ctx(- context={- "bus": bus,- "agent_id": "root-1",- "parent_id": None,- "agent_factory": fake_factory,- "sandbox_session": None,- "sandbox_client": None,- "sandbox_token": "token",- "tool_server_host_port": 12345,- "caido_host_port": None,- "tracer": None,- "model": "anthropic/claude-sonnet-4-6",- "model_settings": None,- "max_turns": 300,- "is_whitebox": False,- }- )-- with patch(- "strix.tools.agents_graph.tools.Runner.run",- side_effect=fake_runner_run,- ):- out = await _invoke(- create_agent,- ctx,- name="recon-bot",- task="enumerate hosts",- inherit_context=False,- skills=["recon"],- )- # The spawned task must be allowed to run so Runner.run side-effect- # records the call.- new_id = out["agent_id"]- await asyncio.gather(*(t for t in bus.tasks.values()), return_exceptions=True)-- assert out["success"] is True- assert factory_calls == [{"name": "recon-bot", "skills": ["recon"]}]- assert len(runner_calls) == 1-- # Bus state: child registered, task stored.- assert new_id in bus.statuses- assert bus.parent_of[new_id] == "root-1"- assert bus.names[new_id] == "recon-bot"- assert new_id in bus.tasks-- # Initial input shape: identity preamble + task message at the end.- initial_input = runner_calls[0]["kwargs"]["input"]- assert any(- isinstance(item, dict) and "You are agent recon-bot" in item.get("content", "")- for item in initial_input- )- assert initial_input[-1]["content"] == "enumerate hosts"---async def test_create_agent_inherits_parent_history() -> None:- bus = await _make_bus_with_agents()-- def fake_factory(*, name: str, skills: list[str]) -> Any:- return object()-- runner_calls: list[dict[str, Any]] = []-- async def fake_runner_run(*args: Any, **kwargs: Any) -> Any:- runner_calls.append(kwargs)- return None-- parent_history = [- {"role": "user", "content": "scope: example.com"},- {"role": "assistant", "content": "I'll start with subdomain enum."},- ]- ctx = _Ctx(- context={- "bus": bus,- "agent_id": "root-1",- "parent_id": None,- "agent_factory": fake_factory,- "parent_input_items": parent_history,- "sandbox_session": None,- "sandbox_client": None,- "sandbox_token": "token",- "tool_server_host_port": 12345,- "caido_host_port": None,- "tracer": None,- "model": "anthropic/claude-sonnet-4-6",- "model_settings": None,- "max_turns": 300,- }- )-- with patch(- "strix.tools.agents_graph.tools.Runner.run",- side_effect=fake_runner_run,- ):- await _invoke(- create_agent,- ctx,- name="child",- task="do thing",- inherit_context=True,- )- await asyncio.gather(*(t for t in bus.tasks.values()), return_exceptions=True)-- initial_input = runner_calls[0]["input"]- contents = [item.get("content", "") for item in initial_input]- assert any("Inherited context from parent" in c for c in contents)- assert any("End of inherited context" in c for c in contents)- # Parent's exact items should be in between.- assert any(c == "scope: example.com" for c in contents)---# --- agent_finish -----------------------------------------------------------async def test_agent_finish_rejects_root() -> None:- bus = await _make_bus_with_agents()- out = await _invoke(- agent_finish,- _ctx_for(bus, agent_id="root-1"),- result_summary="done",- )- assert out["success"] is False- assert "agent_finish is for subagents" in out["error"]---async def test_agent_finish_posts_report_to_parent_inbox() -> None:- bus = await _make_bus_with_agents()- ctx = _Ctx(- context={- "bus": bus,- "agent_id": "child-A",- "parent_id": "root-1",- "agent_finish_called": False,- }- )- out = await _invoke(- agent_finish,- ctx,- result_summary="found 3 issues",- findings=["xss in /search", "open redirect", "stored xss"],- final_recommendations=["sanitize search input"],- success=True,- )- assert out["success"] is True- assert out["agent_completed"] is True- assert out["parent_notified"] is True-- # Side effects: agent_finish_called flipped (so on_agent_end records- # "completed", not "crashed"), and the parent's inbox got the report.- assert ctx.context["agent_finish_called"] is True- parent_msgs = await bus.drain("root-1")- assert len(parent_msgs) == 1- msg = parent_msgs[0]- assert msg["type"] == "completion"- assert msg["from"] == "child-A"- payload = json.loads(msg["content"])- assert payload["kind"] == "agent_completion_report"- assert payload["summary"] == "found 3 issues"- assert "xss in /search" in payload["findings"]- assert "sanitize search input" in payload["recommendations"]---async def test_agent_finish_skips_parent_when_report_to_parent_false() -> None:- bus = await _make_bus_with_agents()- ctx = _Ctx(- context={- "bus": bus,- "agent_id": "child-A",- "parent_id": "root-1",- "agent_finish_called": False,- }- )- out = await _invoke(- agent_finish,- ctx,- result_summary="silent done",- report_to_parent=False,- )- assert out["success"] is True- assert out["parent_notified"] is False- assert ctx.context["agent_finish_called"] is True- parent_msgs = await bus.drain("root-1")- assert parent_msgs == []---# --- bus integration sanity ------------------------------------------------async def test_create_agent_spawn_is_cancelable_via_bus() -> None:- """Verify bus.cancel_descendants reaches a child task we just spawned."""- bus = await _make_bus_with_agents()-- def fake_factory(*, name: str, skills: list[str]) -> Any:- return object()-- # Long-lived child that yields control so we can cancel it before it- # finishes naturally.- async def slow_runner_run(*args: Any, **kwargs: Any) -> Any:- await asyncio.sleep(60)- return None-- ctx = _Ctx(- context={- "bus": bus,- "agent_id": "root-1",- "parent_id": None,- "agent_factory": fake_factory,- "sandbox_session": None,- "sandbox_client": None,- "sandbox_token": "t",- "tool_server_host_port": 12345,- "caido_host_port": None,- "tracer": None,- "model": "anthropic/claude-sonnet-4-6",- "model_settings": None,- "max_turns": 300,- }- )-- runner_mock = AsyncMock(side_effect=slow_runner_run)- with patch(- "strix.tools.agents_graph.tools.Runner.run",- new=runner_mock,- ):- out = await _invoke(- create_agent,- ctx,- name="long-running",- task="do thing",- inherit_context=False,- )- child_id = out["agent_id"]- # Let the task actually start.- await asyncio.sleep(0.05)- await bus.cancel_descendants("root-1")-- # The cancel should have propagated; the task is done (cancelled).- assert bus.tasks[child_id].done()diff --git a/tests/tools/test_local_tools.py b/tests/tools/test_local_tools.pydeleted file mode 100644index bab8e7d0..00000000--- a/tests/tools/test_local_tools.py+++ /dev/null@@ -1,250 +0,0 @@-"""Phase 2.3 smoke tests for the simplest SDK-wrapped local tools.--Validates the wrapping pattern (legacy implementation in, JSON string out)-on three tool families: think (trivial), todo (in-memory + agent_state-adapter), notes (in-memory + JSONL persistence).--If this slice works end-to-end the same pattern carries the rest of the-local tools (reporting, web_search, file_edit, finish_scan, load_skill).-"""--from __future__ import annotations--import json-from collections.abc import Iterator-from dataclasses import dataclass, field-from pathlib import Path-from typing import Any-from unittest.mock import patch--import pytest-from agents.tool import FunctionTool--from strix.tools.notes import tools as _notes_impl-from strix.tools.notes.tools import (- create_note,- delete_note,- get_note,- list_notes,- update_note,-)-from strix.tools.thinking.tool import think-from strix.tools.todo.tools import (- create_todo,- delete_todo,- list_todos,- mark_todo_done,- mark_todo_pending,- update_todo,-)---@dataclass-class _Ctx:- """Stand-in for ``RunContextWrapper``."""-- context: dict[str, Any] = field(default_factory=dict)---def _ctx_for(agent_id: str = "test-agent") -> _Ctx:- return _Ctx(context={"agent_id": agent_id})---async def _invoke(tool: FunctionTool, ctx: _Ctx, **kwargs: Any) -> dict[str, Any]:- """Invoke a function tool the way the SDK would and JSON-decode the result."""- from agents.tool_context import ToolContext-- tool_ctx = ToolContext(- context=ctx.context,- usage=None,- tool_name=tool.name,- tool_call_id="test-call-id",- tool_arguments=json.dumps(kwargs),- )- result = await tool.on_invoke_tool(tool_ctx, json.dumps(kwargs))- assert isinstance(result, str)- decoded = json.loads(result)- assert isinstance(decoded, dict)- return decoded---# --- think -------------------------------------------------------------------def test_think_is_a_function_tool() -> None:- assert isinstance(think, FunctionTool)- assert think.name == "think"---async def test_think_records_thought() -> None:- ctx = _ctx_for()- thought = "planning my next move"- out = await _invoke(think, ctx, thought=thought)- assert out["success"] is True- assert f"{len(thought)} characters" in out["message"]---async def test_think_rejects_empty() -> None:- ctx = _ctx_for()- out = await _invoke(think, ctx, thought=" ")- assert out["success"] is False---# --- todo -------------------------------------------------------------------[email protected](autouse=True)-def _isolate_todo_storage() -> None:- """Each test starts with an empty todo store so tests don't bleed."""- from strix.tools.todo import tools as todo_module-- todo_module._todos_storage.clear()---def test_todo_tools_are_function_tools() -> None:- for tool in (- create_todo,- list_todos,- update_todo,- mark_todo_done,- mark_todo_pending,- delete_todo,- ):- assert isinstance(tool, FunctionTool)---async def test_todo_lifecycle() -> None:- ctx = _ctx_for("agent-A")-- # Create- created = await _invoke(create_todo, ctx, title="audit endpoint", priority="high")- assert created["success"] is True- assert created["count"] == 1- todo_id = created["created"][0]["todo_id"]-- # List- listed = await _invoke(list_todos, ctx)- assert listed["success"] is True- assert any(t["todo_id"] == todo_id for t in listed["todos"])-- # Update- updated = await _invoke(update_todo, ctx, todo_id=todo_id, status="in_progress")- assert updated["success"] is True-- # Mark done- done = await _invoke(mark_todo_done, ctx, todo_id=todo_id)- assert done["success"] is True-- # Reset to pending- pending = await _invoke(mark_todo_pending, ctx, todo_id=todo_id)- assert pending["success"] is True-- # Delete- deleted = await _invoke(delete_todo, ctx, todo_id=todo_id)- assert deleted["success"] is True---async def test_todos_are_per_agent_isolated() -> None:- """Two agents should have independent todo stores."""- ctx_a = _ctx_for("agent-A")- ctx_b = _ctx_for("agent-B")-- await _invoke(create_todo, ctx_a, title="A's task")- await _invoke(create_todo, ctx_b, title="B's task")-- list_a = await _invoke(list_todos, ctx_a)- list_b = await _invoke(list_todos, ctx_b)-- titles_a = [t["title"] for t in list_a["todos"]]- titles_b = [t["title"] for t in list_b["todos"]]- assert titles_a == ["A's task"]- assert titles_b == ["B's task"]---async def test_create_todo_bulk_via_json_string() -> None:- ctx = _ctx_for()- out = await _invoke(- create_todo,- ctx,- todos=json.dumps(- [- {"title": "t1", "priority": "high"},- {"title": "t2", "priority": "low"},- ],- ),- )- assert out["success"] is True- assert out["count"] == 2---# --- notes -------------------------------------------------------------------def notes_run_dir(tmp_path: Path) -> Iterator[Path]:- """Point the legacy notes module at a fresh run dir per test."""- run_dir = tmp_path / "strix_runs" / "test"- run_dir.mkdir(parents=True)- _notes_impl._notes_storage.clear()- _notes_impl._loaded_notes_run_dir = None-- with patch.object(_notes_impl, "_get_run_dir", return_value=run_dir):- yield run_dir---def test_notes_tools_are_function_tools() -> None:- for tool in (create_note, list_notes, get_note, update_note, delete_note):- assert isinstance(tool, FunctionTool)---async def test_note_lifecycle(notes_run_dir: Path) -> None:- ctx = _ctx_for()-- created = await _invoke(- create_note,- ctx,- title="SQLi at /login",- content="Form param `email` reflects into the WHERE clause.",- category="findings",- tags=["sqli", "auth"],- )- assert created["success"] is True- note_id = created["note_id"]-- listed = await _invoke(list_notes, ctx, category="findings")- assert listed["success"] is True- assert listed["total_count"] == 1-- fetched = await _invoke(get_note, ctx, note_id=note_id)- assert fetched["success"] is True- assert "WHERE clause" in fetched["note"]["content"]-- updated = await _invoke(- update_note,- ctx,- note_id=note_id,- content="Confirmed boolean-blind SQLi.",- )- assert updated["success"] is True-- deleted = await _invoke(delete_note, ctx, note_id=note_id)- assert deleted["success"] is True---async def test_notes_jsonl_appended(notes_run_dir: Path) -> None:- """Verify side effect: notes.jsonl receives one event per op."""- ctx = _ctx_for()- await _invoke(create_note, ctx, title="t", content="c", category="general")-- jsonl = notes_run_dir / "notes" / "notes.jsonl"- assert jsonl.exists()- events = [json.loads(line) for line in jsonl.read_text().splitlines() if line]- assert events[0]["op"] == "create"- assert events[0]["note"]["title"] == "t"diff --git a/tests/tools/test_notes_jsonl_concurrency.py b/tests/tools/test_notes_jsonl_concurrency.pydeleted file mode 100644index 71ee9f0e..00000000--- a/tests/tools/test_notes_jsonl_concurrency.py+++ /dev/null@@ -1,79 +0,0 @@-"""C6 regression test — concurrent notes JSONL writes must produce valid JSONL.--This test would fail before the C6 fix (AUDIT_R2 §1.1, applied in Phase 2.2):-the legacy ``_append_note_event`` opened the file and called ``f.write``-without holding ``_notes_lock``, so two threads writing simultaneously-could interleave bytes mid-line and corrupt the JSONL.-"""--from __future__ import annotations--import json-import threading-from collections.abc import Iterator-from pathlib import Path-from typing import Any-from unittest.mock import patch--import pytest--from strix.tools.notes.tools import _append_note_event---def notes_path(tmp_path: Path) -> Iterator[Path]:- """Point ``_get_notes_jsonl_path`` at a tmp file for the test."""- target = tmp_path / "notes" / "notes.jsonl"- target.parent.mkdir(parents=True, exist_ok=True)-- with patch(- "strix.tools.notes.tools._get_notes_jsonl_path",- return_value=target,- ):- yield target---def test_concurrent_note_writes_yield_valid_jsonl(notes_path: Path) -> None:- """C6 fix: 50 threads x 20 events = 1000 lines, all valid JSON.-- Without the lock, byte-level interleaving on the file produces- fragments like ``{"timesta{"timestamp"...`` that fail json.loads.- """-- def writer(thread_idx: int) -> None:- for i in range(20):- note: dict[str, Any] = {- "title": f"thread-{thread_idx}-note-{i}",- "content": "x" * 200, # non-trivial body to widen the race- "category": "general",- }- _append_note_event(- op="create",- note_id=f"t{thread_idx}-i{i}",- note=note,- )-- threads = [threading.Thread(target=writer, args=(t,)) for t in range(50)]- for t in threads:- t.start()- for t in threads:- t.join()-- lines = notes_path.read_text(encoding="utf-8").splitlines()- assert len(lines) == 1000, f"expected 1000 lines, got {len(lines)}"- for line in lines:- # raises if the line is malformed JSON- event = json.loads(line)- assert event["op"] == "create"- assert "note_id" in event---def test_single_writer_still_works(notes_path: Path) -> None:- """Sanity: serial writes still produce a valid JSONL log."""- _append_note_event("create", "n1", {"title": "first"})- _append_note_event("update", "n1", {"title": "first updated"})- _append_note_event("delete", "n1")-- events = [json.loads(line) for line in notes_path.read_text().splitlines()]- assert [e["op"] for e in events] == ["create", "update", "delete"]- assert all(e["note_id"] == "n1" for e in events)diff --git a/tests/tools/test_notes_wiki.py b/tests/tools/test_notes_wiki.pydeleted file mode 100644index 2db4ab7f..00000000--- a/tests/tools/test_notes_wiki.py+++ /dev/null@@ -1,187 +0,0 @@-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---def _reset_notes_state() -> None:- notes_actions._notes_storage.clear()- notes_actions._loaded_notes_run_dir = None---def test_wiki_notes_are_persisted_and_removed(- tmp_path: Path, monkeypatch: pytest.MonkeyPatch-) -> None:- monkeypatch.chdir(tmp_path)- _reset_notes_state()-- previous_tracer = get_global_tracer()- tracer = Tracer("wiki-test-run")- set_global_tracer(tracer)-- try:- created = notes_actions._create_note_impl(- title="Repo Map",- content="## Architecture\n- monolith",- category="wiki",- tags=["source-map"],- )- assert created["success"] is True- note_id = created["note_id"]- assert isinstance(note_id, str)-- note = notes_actions._notes_storage[note_id]- wiki_filename = note.get("wiki_filename")- assert isinstance(wiki_filename, str)-- wiki_path = tmp_path / "strix_runs" / "wiki-test-run" / "wiki" / wiki_filename- assert wiki_path.exists()- assert "## Architecture" in wiki_path.read_text(encoding="utf-8")-- updated = notes_actions._update_note_impl(- note_id=note_id,- content="## Architecture\n- service-oriented",- )- assert updated["success"] is True- assert "service-oriented" in wiki_path.read_text(encoding="utf-8")-- deleted = notes_actions._delete_note_impl(note_id=note_id)- assert deleted["success"] is True- assert wiki_path.exists() is False- finally:- _reset_notes_state()- set_global_tracer(previous_tracer)---def test_notes_jsonl_replay_survives_memory_reset(- tmp_path: Path, monkeypatch: pytest.MonkeyPatch-) -> None:- monkeypatch.chdir(tmp_path)- _reset_notes_state()-- previous_tracer = get_global_tracer()- tracer = Tracer("notes-replay-run")- set_global_tracer(tracer)-- try:- created = notes_actions._create_note_impl(- title="Auth findings",- content="initial finding",- category="findings",- tags=["auth"],- )- assert created["success"] is True- note_id = created["note_id"]- assert isinstance(note_id, str)-- notes_path = tmp_path / "strix_runs" / "notes-replay-run" / "notes" / "notes.jsonl"- assert notes_path.exists() is True-- _reset_notes_state()- listed = notes_actions._list_notes_impl(category="findings")- assert listed["success"] is True- assert listed["total_count"] == 1- assert listed["notes"][0]["note_id"] == note_id- assert "content" not in listed["notes"][0]- assert "content_preview" in listed["notes"][0]-- updated = notes_actions._update_note_impl(note_id=note_id, content="updated finding")- assert updated["success"] is True-- _reset_notes_state()- listed_after_update = notes_actions._list_notes_impl(search="updated finding")- assert listed_after_update["success"] is True- assert listed_after_update["total_count"] == 1- assert listed_after_update["notes"][0]["note_id"] == note_id- assert listed_after_update["notes"][0]["content_preview"] == "updated finding"-- listed_with_content = notes_actions._list_notes_impl(- category="findings",- include_content=True,- )- assert listed_with_content["success"] is True- assert listed_with_content["total_count"] == 1- assert listed_with_content["notes"][0]["content"] == "updated finding"-- deleted = notes_actions._delete_note_impl(note_id=note_id)- assert deleted["success"] is True-- _reset_notes_state()- listed_after_delete = notes_actions._list_notes_impl(category="findings")- assert listed_after_delete["success"] is True- assert listed_after_delete["total_count"] == 0- finally:- _reset_notes_state()- set_global_tracer(previous_tracer)---def test_get_note_returns_full_note(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:- monkeypatch.chdir(tmp_path)- _reset_notes_state()-- previous_tracer = get_global_tracer()- tracer = Tracer("get-note-run")- set_global_tracer(tracer)-- try:- created = notes_actions._create_note_impl(- title="Repo wiki",- content="entrypoints and sinks",- category="wiki",- tags=["repo:appsmith"],- )- assert created["success"] is True- note_id = created["note_id"]- assert isinstance(note_id, str)-- result = notes_actions._get_note_impl(note_id=note_id)- assert result["success"] is True- assert result["note"]["note_id"] == note_id- assert result["note"]["content"] == "entrypoints and sinks"- finally:- _reset_notes_state()- set_global_tracer(previous_tracer)---def test_list_and_get_note_handle_wiki_repersist_oserror_gracefully(- tmp_path: Path, monkeypatch: pytest.MonkeyPatch-) -> None:- monkeypatch.chdir(tmp_path)- _reset_notes_state()-- previous_tracer = get_global_tracer()- tracer = Tracer("wiki-repersist-oserror-run")- set_global_tracer(tracer)-- try:- created = notes_actions._create_note_impl(- title="Repo wiki",- content="initial wiki content",- category="wiki",- tags=["repo:demo"],- )- assert created["success"] is True- note_id = created["note_id"]- assert isinstance(note_id, str)-- _reset_notes_state()-- def _raise_oserror(*_args: object, **_kwargs: object) -> None:- raise OSError("disk full")-- monkeypatch.setattr(notes_actions, "_persist_wiki_note", _raise_oserror)-- listed = notes_actions._list_notes_impl(category="wiki")- assert listed["success"] is True- assert listed["total_count"] == 1- assert listed["notes"][0]["note_id"] == note_id-- fetched = notes_actions._get_note_impl(note_id=note_id)- assert fetched["success"] is True- assert fetched["note"]["note_id"] == note_id- assert fetched["note"]["content"] == "initial wiki content"- finally:- _reset_notes_state()- set_global_tracer(previous_tracer)diff --git a/tests/tools/test_remaining_local_tools.py b/tests/tools/test_remaining_local_tools.pydeleted file mode 100644index f4958bdd..00000000--- a/tests/tools/test_remaining_local_tools.py+++ /dev/null@@ -1,305 +0,0 @@-"""Smoke tests for the remaining local SDK tool wrappers.--Covers: web_search, file_edit (str_replace_editor + list_files +-search_files), reporting (create_vulnerability_report), finish_scan.-"""--from __future__ import annotations--import json-from dataclasses import dataclass, field-from typing import Any-from unittest.mock import patch--import pytest-from agents.tool import FunctionTool--from strix.tools.file_edit.tools import (- list_files,- search_files,- str_replace_editor,-)-from strix.tools.finish.tool import finish_scan-from strix.tools.reporting.tool import create_vulnerability_report-from strix.tools.web_search.tool import web_search---@dataclass-class _Ctx:- context: dict[str, Any] = field(default_factory=dict)---def _ctx_for(agent_id: str = "test-agent") -> _Ctx:- return _Ctx(- context={- "agent_id": agent_id,- "tool_server_host_port": 12345,- "sandbox_token": "test-token",- },- )---async def _invoke(tool: FunctionTool, ctx: _Ctx, **kwargs: Any) -> dict[str, Any]:- from agents.tool_context import ToolContext-- tool_ctx = ToolContext(- context=ctx.context,- usage=None,- tool_name=tool.name,- tool_call_id="test-call-id",- tool_arguments=json.dumps(kwargs),- )- result = await tool.on_invoke_tool(tool_ctx, json.dumps(kwargs))- assert isinstance(result, str)- decoded = json.loads(result)- assert isinstance(decoded, dict)- return decoded---def test_all_remaining_tools_are_function_tools() -> None:- for tool in (- web_search,- str_replace_editor,- list_files,- search_files,- create_vulnerability_report,- finish_scan,- ):- assert isinstance(tool, FunctionTool)---# --- web_search --------------------------------------------------------------async def test_web_search_no_api_key_returns_structured_error(- monkeypatch: pytest.MonkeyPatch,-) -> None:- """The legacy function returns a structured error when the env var is- missing — verify the wrapper passes that through verbatim."""- monkeypatch.delenv("PERPLEXITY_API_KEY", raising=False)-- out = await _invoke(web_search, _ctx_for(), query="anything")- assert out["success"] is False- assert "PERPLEXITY_API_KEY" in out["message"]---async def test_web_search_delegates_to_perplexity(monkeypatch: pytest.MonkeyPatch) -> None:- """The wrapper invokes the Perplexity HTTP path on a thread."""- monkeypatch.setenv("PERPLEXITY_API_KEY", "fake-key")-- fake_result = {- "success": True,- "query": "xss techniques",- "content": "Reflected XSS payload examples...",- "message": "Web search completed successfully",- }- with patch(- "strix.tools.web_search.tool._do_search",- return_value=fake_result,- ) as do_search:- out = await _invoke(web_search, _ctx_for(), query="xss techniques")-- assert out == fake_result- do_search.assert_called_once_with("xss techniques")---# --- file_edit (sandbox-bound) ----------------------------------------------async def test_str_replace_editor_routes_to_sandbox() -> None:- """file_edit tools must POST to the in-sandbox tool server, not run locally."""- fake_response = {"result": {"content": "file viewed"}}- with patch(- "strix.tools.file_edit.tools.post_to_sandbox",- return_value=fake_response,- ) as dispatch:- out = await _invoke(- str_replace_editor,- _ctx_for(),- command="view",- path="src/foo.py",- )-- assert out == fake_response- assert dispatch.call_count == 1- # post_to_sandbox is called positionally as (ctx, tool_name, kwargs).- args, _ = dispatch.call_args- assert args[1] == "str_replace_editor"- assert args[2]["command"] == "view"- assert args[2]["path"] == "src/foo.py"- # All optional file-edit params are forwarded as None (parity with legacy schema).- assert args[2]["file_text"] is None- assert args[2]["old_str"] is None---async def test_list_files_routes_to_sandbox() -> None:- fake_response = {"result": {"files": ["a.py"], "directories": []}}- with patch(- "strix.tools.file_edit.tools.post_to_sandbox",- return_value=fake_response,- ) as dispatch:- out = await _invoke(list_files, _ctx_for(), path="src", recursive=True)-- assert out == fake_response- args, _ = dispatch.call_args- assert args[1] == "list_files"- assert args[2] == {"path": "src", "recursive": True}---async def test_search_files_routes_to_sandbox() -> None:- fake_response = {"result": {"output": "src/foo.py:1:match"}}- with patch(- "strix.tools.file_edit.tools.post_to_sandbox",- return_value=fake_response,- ) as dispatch:- out = await _invoke(- search_files,- _ctx_for(),- path="src",- regex="TODO",- file_pattern="*.py",- )-- assert out == fake_response- args, _ = dispatch.call_args- assert args[1] == "search_files"- assert args[2] == {"path": "src", "regex": "TODO", "file_pattern": "*.py"}---# --- reporting --------------------------------------------------------------async def test_create_vulnerability_report_validates_required_fields() -> None:- """Empty required fields should be rejected by the validator."""- out = await _invoke(- create_vulnerability_report,- _ctx_for(),- title="", # empty -> validation error- description="d",- impact="i",- target="t",- technical_analysis="ta",- poc_description="pd",- poc_script_code="curl ...",- remediation_steps="rs",- cvss_breakdown={"attack_vector": "N"},- )- assert out["success"] is False- assert "errors" in out- assert any("Title" in e for e in out["errors"])---async def test_create_vulnerability_report_delegates_to_impl() -> None:- """Verify the wrapper threads its kwargs through to the implementation."""- fake_result = {- "success": True,- "message": "Vulnerability report 'X' created successfully",- "report_id": "abc123",- "severity": "high",- "cvss_score": 7.5,- }- with patch(- "strix.tools.reporting.tool._do_create",- return_value=fake_result,- ) as do_create:- out = await _invoke(- create_vulnerability_report,- _ctx_for(),- title="t",- description="d",- impact="i",- target="tg",- technical_analysis="ta",- poc_description="pd",- poc_script_code="pc",- remediation_steps="rs",- cvss_breakdown={"attack_vector": "N"},- cve="CVE-2024-12345",- )-- assert out == fake_result- kwargs = do_create.call_args.kwargs- assert kwargs["title"] == "t"- assert kwargs["cve"] == "CVE-2024-12345"- # Optional params we didn't pass should still be forwarded as None.- assert kwargs["endpoint"] is None- assert kwargs["method"] is None---# --- finish_scan ------------------------------------------------------------async def test_finish_scan_validates_empty_fields() -> None:- """Legacy validation: every section must be non-empty."""- out = await _invoke(- finish_scan,- _ctx_for(),- executive_summary="",- methodology="m",- technical_analysis="ta",- recommendations="r",- )- assert out["success"] is False- assert any("Executive summary" in e for e in out["errors"])---async def test_finish_scan_rejects_subagent() -> None:- """A subagent (parent_id is set) must not be able to finish the scan."""- ctx = _Ctx(- context={- "agent_id": "child-1",- "parent_id": "root-1",- "tool_server_host_port": 12345,- "sandbox_token": "test-token",- },- )- out = await _invoke(- finish_scan,- ctx,- executive_summary="es",- methodology="m",- technical_analysis="ta",- recommendations="r",- )- assert out["success"] is False- assert out["error"] == "finish_scan_wrong_agent"---async def test_finish_scan_persists_via_tracer() -> None:- """When a global tracer exists, finish_scan should write the four sections."""- from unittest.mock import MagicMock-- fake_tracer = MagicMock()- fake_tracer.vulnerability_reports = [{}, {}, {}]-- with patch(- "strix.telemetry.tracer.get_global_tracer",- return_value=fake_tracer,- ):- out = await _invoke(- finish_scan,- _ctx_for("root-agent"),- executive_summary="es",- methodology="m",- technical_analysis="ta",- recommendations="r",- )-- assert out["success"] is True- assert out["vulnerabilities_found"] == 3- fake_tracer.update_scan_final_fields.assert_called_once_with(- executive_summary="es",- methodology="m",- technical_analysis="ta",- recommendations="r",- )diff --git a/tests/tools/test_sandbox_dispatch.py b/tests/tools/test_sandbox_dispatch.pydeleted file mode 100644index f9d175a1..00000000--- a/tests/tools/test_sandbox_dispatch.py+++ /dev/null@@ -1,206 +0,0 @@-"""Phase 2.1 smoke tests for the sandbox dispatch helper."""--from __future__ import annotations--from dataclasses import dataclass, field-from typing import Any--import httpx-import pytest--from strix.tools._sandbox_dispatch import post_to_sandbox---@dataclass-class _Ctx:- """Stand-in for ``RunContextWrapper``. Only ``.context`` is touched."""-- context: dict[str, Any] = field(default_factory=dict)---def _ok_ctx(**overrides: Any) -> _Ctx:- base: dict[str, Any] = {- "tool_server_host_port": 48081,- "sandbox_token": "test-bearer",- "agent_id": "agent-1",- }- base.update(overrides)- return _Ctx(context=base)---async def test_missing_context_returns_error() -> None:- """If ``ctx.context`` isn't a dict, return error — never raise."""- ctx = _Ctx(context="not a dict")- result = await post_to_sandbox(ctx, "browser_action", {"action": "launch"})- assert "error" in result- assert "context" in result["error"].lower()---async def test_missing_port_or_token_returns_error() -> None:- ctx = _Ctx(context={"sandbox_token": "tok"}) # no port- result = await post_to_sandbox(ctx, "x", {})- assert "error" in result- assert "tool server port" in result["error"].lower()---async def test_successful_response_returned_as_dict(- monkeypatch: pytest.MonkeyPatch,-) -> None:- captured: dict[str, Any] = {}-- async def fake_post(- self: httpx.AsyncClient,- url: str,- *,- json: dict[str, Any] | None = None,- headers: dict[str, str] | None = None,- ) -> httpx.Response:- captured["url"] = url- captured["json"] = json- captured["headers"] = headers- return httpx.Response(- status_code=200,- json={"result": "ok"},- request=httpx.Request("POST", url),- )-- monkeypatch.setattr(httpx.AsyncClient, "post", fake_post)-- result = await post_to_sandbox(_ok_ctx(), "terminal_execute", {"command": "ls"})- assert result == {"result": "ok"}- assert captured["url"] == "http://127.0.0.1:48081/execute"- assert captured["json"] == {- "agent_id": "agent-1",- "tool_name": "terminal_execute",- "kwargs": {"command": "ls"},- }- assert captured["headers"]["Authorization"] == "Bearer test-bearer"---async def test_401_returns_auth_error(monkeypatch: pytest.MonkeyPatch) -> None:- async def fake_post(- self: httpx.AsyncClient,- url: str,- **_: Any,- ) -> httpx.Response:- return httpx.Response(- status_code=401,- text="forbidden",- request=httpx.Request("POST", url),- )-- monkeypatch.setattr(httpx.AsyncClient, "post", fake_post)- result = await post_to_sandbox(_ok_ctx(), "x", {})- assert "error" in result- assert "authorization" in result["error"].lower()---async def test_5xx_returns_http_error(monkeypatch: pytest.MonkeyPatch) -> None:- async def fake_post(- self: httpx.AsyncClient,- url: str,- **_: Any,- ) -> httpx.Response:- return httpx.Response(- status_code=503,- text="server fell over",- request=httpx.Request("POST", url),- )-- monkeypatch.setattr(httpx.AsyncClient, "post", fake_post)- result = await post_to_sandbox(_ok_ctx(), "browser_action", {})- assert "error" in result- assert "503" in result["error"]---async def test_timeout_returns_timeout_error(monkeypatch: pytest.MonkeyPatch) -> None:- async def fake_post(*_args: Any, **_kwargs: Any) -> httpx.Response:- raise httpx.ReadTimeout("read timeout")-- monkeypatch.setattr(httpx.AsyncClient, "post", fake_post)- result = await post_to_sandbox(_ok_ctx(), "python_action", {})- assert "error" in result- assert "timed out" in result["error"].lower()---async def test_connection_error_returns_error(monkeypatch: pytest.MonkeyPatch) -> None:- async def fake_post(*_args: Any, **_kwargs: Any) -> httpx.Response:- raise httpx.ConnectError("refused")-- monkeypatch.setattr(httpx.AsyncClient, "post", fake_post)- result = await post_to_sandbox(_ok_ctx(), "x", {})- assert "error" in result- assert "connection" in result["error"].lower()---async def test_response_too_large_capped(monkeypatch: pytest.MonkeyPatch) -> None:- """C18 (AUDIT_R3): response > 50MB returns error, doesn't OOM."""-- async def fake_post(- self: httpx.AsyncClient,- url: str,- **_: Any,- ) -> httpx.Response:- # Construct a response with a >50MB body. Use a string trick —- # httpx.Response stores .content directly; we make it look huge.- big = b"x" * (51 * 1024 * 1024)- return httpx.Response(- status_code=200,- content=big,- request=httpx.Request("POST", url),- )-- monkeypatch.setattr(httpx.AsyncClient, "post", fake_post)- result = await post_to_sandbox(_ok_ctx(), "browser_action", {})- assert "error" in result- assert "too large" in result["error"].lower()---async def test_non_json_response_returns_error(- monkeypatch: pytest.MonkeyPatch,-) -> None:- async def fake_post(- self: httpx.AsyncClient,- url: str,- **_: Any,- ) -> httpx.Response:- return httpx.Response(- status_code=200,- text="hello not json",- request=httpx.Request("POST", url),- )-- monkeypatch.setattr(httpx.AsyncClient, "post", fake_post)- result = await post_to_sandbox(_ok_ctx(), "x", {})- assert "error" in result- assert "non-json" in result["error"].lower()---async def test_non_object_json_returns_error(- monkeypatch: pytest.MonkeyPatch,-) -> None:- async def fake_post(- self: httpx.AsyncClient,- url: str,- **_: Any,- ) -> httpx.Response:- return httpx.Response(- status_code=200,- json=["a", "list", "not", "an", "object"],- request=httpx.Request("POST", url),- )-- monkeypatch.setattr(httpx.AsyncClient, "post", fake_post)- result = await post_to_sandbox(_ok_ctx(), "x", {})- assert "error" in result- assert "non-object" in result["error"].lower()diff --git a/tests/tools/test_sandbox_tools.py b/tests/tools/test_sandbox_tools.pydeleted file mode 100644index f6bd0546..00000000--- a/tests/tools/test_sandbox_tools.py+++ /dev/null@@ -1,348 +0,0 @@-"""Smoke tests for the sandbox-bound SDK tool wrappers.--Covers: browser_action, terminal_execute, python_action, file_edit-helpers, and the seven Caido proxy tools.--These wrappers are pure pass-throughs to ``post_to_sandbox`` — there's-no per-tool logic to assert, so the tests focus on:--- ``FunctionTool`` registration succeeds (which proves the SDK could- derive a JSON schema from the type hints — a non-trivial check given- Literal types, ``dict[str, str]``, and strict-mode opt-outs).-- The dispatch payload to ``post_to_sandbox`` carries the right- ``kwargs`` shape so the in-container tool server can dispatch to the- matching action.-- The ``send_request`` / ``repeat_request`` tools opt out of strict- schema mode (their ``headers`` / ``modifications`` dicts are- free-form and would otherwise fail registration).-"""--from __future__ import annotations--import json-from dataclasses import dataclass, field-from typing import Any-from unittest.mock import patch--import pytest-from agents.tool import FunctionTool--from strix.tools.browser.tool import browser_action-from strix.tools.proxy.tools import (- list_requests,- list_sitemap,- repeat_request,- scope_rules,- send_request,- view_request,- view_sitemap_entry,-)-from strix.tools.python.tool import python_action-from strix.tools.terminal.tool import terminal_execute---_ALL_SANDBOX_TOOLS = (- browser_action,- terminal_execute,- python_action,- list_requests,- view_request,- send_request,- repeat_request,- scope_rules,- list_sitemap,- view_sitemap_entry,-)---@dataclass-class _Ctx:- context: dict[str, Any] = field(default_factory=dict)---def _ctx_for(agent_id: str = "test-agent") -> _Ctx:- return _Ctx(- context={- "agent_id": agent_id,- "tool_server_host_port": 12345,- "sandbox_token": "test-token",- },- )---async def _invoke(tool: FunctionTool, ctx: _Ctx, **kwargs: Any) -> dict[str, Any]:- from agents.tool_context import ToolContext-- tool_ctx = ToolContext(- context=ctx.context,- usage=None,- tool_name=tool.name,- tool_call_id="test-call-id",- tool_arguments=json.dumps(kwargs),- )- result = await tool.on_invoke_tool(tool_ctx, json.dumps(kwargs))- assert isinstance(result, str)- decoded = json.loads(result)- assert isinstance(decoded, dict)- return decoded---def test_all_sandbox_tools_register() -> None:- for tool in _ALL_SANDBOX_TOOLS:- assert isinstance(tool, FunctionTool)---def test_send_and_repeat_request_opt_out_of_strict_mode() -> None:- """The two free-form-dict tools must turn off strict JSON schema."""- assert send_request.strict_json_schema is False- assert repeat_request.strict_json_schema is False- # All other tools should keep strict mode on (the SDK default).- for tool in (- browser_action,- terminal_execute,- python_action,- list_requests,- view_request,- scope_rules,- list_sitemap,- view_sitemap_entry,- ):- assert tool.strict_json_schema is True, tool.name---# --- browser ------------------------------------------------------------------async def test_browser_action_dispatches_full_payload() -> None:- """All optional browser_action params must forward as None when unset- (the in-container handler distinguishes ``None`` from missing)."""- fake = {"result": {"screenshot": "data:image/png;base64,..."}}- with patch(- "strix.tools.browser.tool.post_to_sandbox",- return_value=fake,- ) as dispatch:- out = await _invoke(- browser_action,- _ctx_for(),- action="goto",- url="https://example.com",- )-- assert out == fake- args, _ = dispatch.call_args- assert args[1] == "browser_action"- payload = args[2]- assert payload["action"] == "goto"- assert payload["url"] == "https://example.com"- # All optional params are present in the payload (as None / defaults)- # so the legacy in-container handler sees the full kwarg surface.- for key in (- "coordinate",- "text",- "tab_id",- "js_code",- "duration",- "key",- "file_path",- ):- assert key in payload, key- assert payload[key] is None- assert payload["clear"] is False---# --- terminal -----------------------------------------------------------------async def test_terminal_execute_dispatches() -> None:- fake = {"result": {"content": "hello\n", "exit_code": 0}}- with patch(- "strix.tools.terminal.tool.post_to_sandbox",- return_value=fake,- ) as dispatch:- out = await _invoke(- terminal_execute,- _ctx_for(),- command="echo hello",- terminal_id="term-1",- )-- assert out == fake- args, _ = dispatch.call_args- assert args[1] == "terminal_execute"- assert args[2]["command"] == "echo hello"- assert args[2]["terminal_id"] == "term-1"- assert args[2]["is_input"] is False- assert args[2]["no_enter"] is False- assert args[2]["timeout"] is None---# --- python ------------------------------------------------------------------async def test_python_action_dispatches() -> None:- fake = {"result": {"stdout": "42\n", "is_running": False}}- with patch(- "strix.tools.python.tool.post_to_sandbox",- return_value=fake,- ) as dispatch:- out = await _invoke(- python_action,- _ctx_for(),- action="execute",- code="print(6*7)",- session_id="sess-1",- )-- assert out == fake- args, _ = dispatch.call_args- assert args[1] == "python_action"- assert args[2] == {- "action": "execute",- "code": "print(6*7)",- "timeout": 30,- "session_id": "sess-1",- }---# --- proxy / Caido -----------------------------------------------------------async def test_list_requests_forwards_full_query() -> None:- fake: dict[str, Any] = {"result": {"requests": []}}- with patch(- "strix.tools.proxy.tools.post_to_sandbox",- return_value=fake,- ) as dispatch:- await _invoke(- list_requests,- _ctx_for(),- httpql_filter="resp.code:eq:500",- page_size=20,- sort_by="response_time",- sort_order="asc",- )-- args, _ = dispatch.call_args- assert args[1] == "list_requests"- assert args[2]["httpql_filter"] == "resp.code:eq:500"- assert args[2]["page_size"] == 20- assert args[2]["sort_by"] == "response_time"- assert args[2]["sort_order"] == "asc"- # Defaults preserved.- assert args[2]["start_page"] == 1- assert args[2]["end_page"] == 1---async def test_view_request_dispatches() -> None:- fake = {"result": {"raw": "GET / HTTP/1.1..."}}- with patch(- "strix.tools.proxy.tools.post_to_sandbox",- return_value=fake,- ) as dispatch:- await _invoke(- view_request,- _ctx_for(),- request_id="req-9",- part="response",- search_pattern="Set-Cookie",- )-- args, _ = dispatch.call_args- assert args[1] == "view_request"- assert args[2]["request_id"] == "req-9"- assert args[2]["part"] == "response"- assert args[2]["search_pattern"] == "Set-Cookie"---async def test_send_request_normalizes_missing_headers() -> None:- """Legacy schema treats omitted ``headers`` as ``{}``; the wrapper must too."""- fake = {"result": {"status": 200}}- with patch(- "strix.tools.proxy.tools.post_to_sandbox",- return_value=fake,- ) as dispatch:- await _invoke(- send_request,- _ctx_for(),- method="POST",- url="https://api.example.com/login",- body='{"u":"x"}',- )-- args, _ = dispatch.call_args- assert args[1] == "send_request"- assert args[2]["headers"] == {} # not None- assert args[2]["method"] == "POST"- assert args[2]["body"] == '{"u":"x"}'---async def test_repeat_request_normalizes_missing_modifications() -> None:- fake = {"result": {"status": 200}}- with patch(- "strix.tools.proxy.tools.post_to_sandbox",- return_value=fake,- ) as dispatch:- await _invoke(repeat_request, _ctx_for(), request_id="req-1")-- args, _ = dispatch.call_args- assert args[1] == "repeat_request"- assert args[2]["modifications"] == {}---async def test_scope_rules_dispatches() -> None:- fake = {"result": {"scope_id": "s-1"}}- with patch(- "strix.tools.proxy.tools.post_to_sandbox",- return_value=fake,- ) as dispatch:- await _invoke(- scope_rules,- _ctx_for(),- action="create",- scope_name="prod",- allowlist=["*.example.com"],- )-- args, _ = dispatch.call_args- assert args[1] == "scope_rules"- assert args[2]["action"] == "create"- assert args[2]["scope_name"] == "prod"- assert args[2]["allowlist"] == ["*.example.com"]- assert args[2]["denylist"] is None---async def test_list_sitemap_defaults() -> None:- fake: dict[str, Any] = {"result": {"entries": []}}- with patch(- "strix.tools.proxy.tools.post_to_sandbox",- return_value=fake,- ) as dispatch:- await _invoke(list_sitemap, _ctx_for())-- args, _ = dispatch.call_args- assert args[1] == "list_sitemap"- assert args[2]["depth"] == "DIRECT"- assert args[2]["page"] == 1---async def test_view_sitemap_entry_dispatches() -> None:- fake = {"result": {"entry_id": "e-1"}}- with patch(- "strix.tools.proxy.tools.post_to_sandbox",- return_value=fake,- ) as dispatch:- await _invoke(view_sitemap_entry, _ctx_for(), entry_id="e-1")-- args, _ = dispatch.call_args- assert args[1] == "view_sitemap_entry"- assert args[2] == {"entry_id": "e-1"}diff --git a/tests/tools/test_tool_registration_modes.py b/tests/tools/test_tool_registration_modes.pydeleted file mode 100644index ac2346af..00000000--- a/tests/tools/test_tool_registration_modes.py+++ /dev/null@@ -1,62 +0,0 @@-import importlib-import sys-from types import ModuleType-from typing import Any--from strix.config import Config-from strix.tools.registry import clear_registry---def _empty_config_load(_cls: type[Config]) -> dict[str, dict[str, str]]:- return {"env": {}}---def _reload_tools_module() -> ModuleType:- clear_registry()-- for name in list(sys.modules):- if name == "strix.tools" or name.startswith("strix.tools."):- sys.modules.pop(name, None)-- return importlib.import_module("strix.tools")---def test_non_sandbox_skips_browser_and_web_search_when_disabled(- monkeypatch: Any,-) -> None:- """Browser registration is gated on STRIX_DISABLE_BROWSER and- web_search on PERPLEXITY_API_KEY; both should stay out of the- in-container ``register_tool`` registry when their gates are off.- Agents_graph is no longer in this registry — those tools are SDK- function tools (host-side only), not in-container tools.- """- monkeypatch.setenv("STRIX_SANDBOX_MODE", "false")- monkeypatch.setenv("STRIX_DISABLE_BROWSER", "true")- monkeypatch.delenv("PERPLEXITY_API_KEY", raising=False)- monkeypatch.setattr(Config, "load", classmethod(_empty_config_load))-- tools = _reload_tools_module()- names = set(tools.get_tool_names())-- assert "browser_action" not in names- assert "web_search" not in names---def test_sandbox_registers_sandbox_tools_but_not_non_sandbox_tools(- monkeypatch: Any,-) -> None:- monkeypatch.setenv("STRIX_SANDBOX_MODE", "true")- monkeypatch.setenv("STRIX_DISABLE_BROWSER", "true")- monkeypatch.delenv("PERPLEXITY_API_KEY", raising=False)- monkeypatch.setattr(Config, "load", classmethod(_empty_config_load))-- tools = _reload_tools_module()- names = set(tools.get_tool_names())-- assert "terminal_execute" in names- assert "python_action" in names- assert "list_requests" in names- assert "create_agent" not in names- assert "finish_scan" not in names- assert "browser_action" not in names- assert "web_search" not in namesdiff --git a/uv.lock b/uv.lockindex 59e20786..94b963ca 100644--- a/uv.lock+++ b/uv.lock@@ -731,90 +731,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" },]-[[package]]-name = "coverage"-version = "7.13.5"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },- { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },- { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },- { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },- { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },- { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },- { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },- { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },- { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },- { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },- { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },- { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },- { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },- { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },- { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },- { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },- { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },- { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },- { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },- { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },- { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },- { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },- { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },- { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },- { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },- { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },- { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },- { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },- { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },- { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },- { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },- { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },- { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },- { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },- { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },- { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },- { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },- { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },- { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },- { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },- { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },- { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },- { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },- { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },- { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },- { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },- { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },- { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },- { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },- { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },- { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },- { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },- { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },- { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },- { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },- { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },- { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },- { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },- { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },- { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },- { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },- { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },- { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },- { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },- { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },- { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },- { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },- { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },- { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },- { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },- { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },- { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },- { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },- { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },- { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },- { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },-]-[[package]]name = "croniter"version = "6.2.2"@@ -1816,15 +1732,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/59/91/aa6bde563e0085a02a435aa99b49ef75b0a4b062635e606dab23ce18d720/inflection-0.5.1-py2.py3-none-any.whl", hash = "sha256:f38b2b640938a4f35ade69ac3d053042959b62a0f1076a5bbaa1b9526605a8a2", size = 9454, upload-time = "2020-08-22T08:16:27.816Z" },]-[[package]]-name = "iniconfig"-version = "2.3.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },-]-[[package]]name = "ipython"version = "9.11.0"@@ -3917,15 +3824,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/c8/c4/cc0229fea55c87d6c9c67fe44a21e2cd28d1d558a5478ed4d617e9fb0c93/playwright-1.58.0-py3-none-win_arm64.whl", hash = "sha256:32ffe5c303901a13a0ecab91d1c3f74baf73b84f4bedbb6b935f5bc11cc98e1b", size = 33085919, upload-time = "2026-01-30T15:09:45.71Z" },]-[[package]]-name = "pluggy"-version = "1.6.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },-]-[[package]]name = "polars"version = "1.39.3"@@ -4468,61 +4366,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/59/d0/bb522283b90853afbf506cd5b71c650cf708829914efd0003d615cf426cd/pyte-0.8.2-py3-none-any.whl", hash = "sha256:85db42a35798a5aafa96ac4d8da78b090b2c933248819157fc0e6f78876a0135", size = 31627, upload-time = "2023-11-12T09:33:41.096Z" },]-[[package]]-name = "pytest"-version = "9.0.2"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "colorama", marker = "sys_platform == 'win32'" },- { name = "iniconfig" },- { name = "packaging" },- { name = "pluggy" },- { name = "pygments" },-]-sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },-]--[[package]]-name = "pytest-asyncio"-version = "1.3.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "pytest" },- { name = "typing-extensions", marker = "python_full_version < '3.13'" },-]-sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },-]--[[package]]-name = "pytest-cov"-version = "7.0.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "coverage" },- { name = "pluggy" },- { name = "pytest" },-]-sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },-]--[[package]]-name = "pytest-mock"-version = "3.15.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "pytest" },-]-sdist = { url = "https://files.pythonhosted.org/packages/68/14/eb014d26be205d38ad5ad20d9a80f7d201472e08167f0bb4361e251084a9/pytest_mock-3.15.1.tar.gz", hash = "sha256:1849a238f6f396da19762269de72cb1814ab44416fa73a8686deac10b0d87a0f", size = 34036, upload-time = "2025-09-16T16:37:27.081Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/5a/cc/06253936f4a7fa2e0f48dfe6d851d9c56df896a9ab09ac019d70b760619c/pytest_mock-3.15.1-py3-none-any.whl", hash = "sha256:0a25e2eb88fe5168d535041d09a4529a188176ae608a6d249ee65abc0949630d", size = 10095, upload-time = "2025-09-16T16:37:25.734Z" },-]-[[package]]name = "python-dateutil"version = "2.9.0.post0"@@ -5471,10 +5314,6 @@ dev = [{ name = "pyinstaller", marker = "python_full_version < '3.15'" },{ name = "pylint" },{ name = "pyright" },- { name = "pytest" },- { name = "pytest-asyncio" },- { name = "pytest-cov" },- { name = "pytest-mock" },{ name = "ruff" },]@@ -5515,10 +5354,6 @@ dev = [{ name = "pyinstaller", marker = "python_full_version >= '3.12' and python_full_version < '3.15'", specifier = ">=6.17.0" },{ name = "pylint", specifier = ">=3.3.7" },{ name = "pyright", specifier = ">=1.1.401" },- { name = "pytest", specifier = ">=8.4.0" },- { name = "pytest-asyncio", specifier = ">=1.0.0" },- { name = "pytest-cov", specifier = ">=6.1.1" },- { name = "pytest-mock", specifier = ">=3.14.1" },{ name = "ruff", specifier = ">=0.11.13" },]