@softspark/ai-toolkit 4.16.0 → 4.17.0

package/scripts/tool_output_filter/invariants.py

@@ -1,40 +0,0 @@
-"""Stateful safety invariants shared by runtime adapters."""
-
-from __future__ import annotations
-
-DEFAULT_FAILURE_LIMIT = 3
-
-# "never-worse" (savings margin missed after the recovery marker) is a benign
-# outcome, not a safety failure: nothing was emitted. Only genuine anomalies
-# may open the breaker.
-_CIRCUIT_FAILURES = frozenset(
-    {
-        "profile-failed",
-        "recovery-failed",
-        "recovery-verification-failed",
-    }
-)
-
-
-class SessionCircuitBreaker:
-    """Open a session-local bypass after consecutive safety failures."""
-
-    __slots__ = ("failure_limit", "consecutive_failures")
-
-    def __init__(
-        self,
-        failure_limit: int = DEFAULT_FAILURE_LIMIT,
-        consecutive_failures: int = 0,
-    ) -> None:
-        self.failure_limit = failure_limit
-        self.consecutive_failures = consecutive_failures
-
-    @property
-    def is_open(self) -> bool:
-        return self.consecutive_failures >= self.failure_limit
-
-    def record(self, fallback_reason: str | None) -> None:
-        if fallback_reason in _CIRCUIT_FAILURES:
-            self.consecutive_failures += 1
-        else:
-            self.consecutive_failures = 0

package/scripts/tool_output_filter/policy.py

@@ -1,153 +0,0 @@
-"""Strict materialized policy contract."""
-
-from __future__ import annotations
-
-import json
-import os
-
-from .contracts import (
-    DEFAULT_MAX_INPUT_BYTES,
-    DEFAULT_MIN_SAVINGS_BYTES,
-    DEFAULT_MIN_SAVINGS_RATIO,
-    FilterMode,
-)
-from .recovery import DEFAULT_MAX_SESSION_BYTES, DEFAULT_TTL_MINUTES
-
-_KNOWN_PROFILES = frozenset({"repeat-lines", "tap-success"})
-_TOP_LEVEL_KEYS = frozenset(
-    {
-        "mode",
-        "profiles",
-        "maxInputBytes",
-        "minSavingsBytes",
-        "minSavingsRatio",
-        "recovery",
-    }
-)
-_RECOVERY_KEYS = frozenset({"mode", "ttlMinutes", "maxSessionBytes"})
-
-
-class OutputFilterPolicy:
-    __slots__ = (
-        "max_input_bytes",
-        "max_session_bytes",
-        "min_savings_bytes",
-        "min_savings_ratio",
-        "mode",
-        "profiles",
-        "ttl_minutes",
-    )
-
-    def __init__(
-        self,
-        mode: FilterMode,
-        profiles: tuple[str, ...],
-        max_input_bytes: int = DEFAULT_MAX_INPUT_BYTES,
-        min_savings_bytes: int = DEFAULT_MIN_SAVINGS_BYTES,
-        min_savings_ratio: float = DEFAULT_MIN_SAVINGS_RATIO,
-        ttl_minutes: int = DEFAULT_TTL_MINUTES,
-        max_session_bytes: int = DEFAULT_MAX_SESSION_BYTES,
-    ) -> None:
-        self.mode = mode
-        self.profiles = profiles
-        self.max_input_bytes = max_input_bytes
-        self.min_savings_bytes = min_savings_bytes
-        self.min_savings_ratio = min_savings_ratio
-        self.ttl_minutes = ttl_minutes
-        self.max_session_bytes = max_session_bytes
-
-
-def _integer(data: dict[str, object], key: str, default: int) -> int:
-    value = data.get(key, default)
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise ValueError(f"{key} must be an integer")
-    return value
-
-
-def _number(data: dict[str, object], key: str, default: float) -> float:
-    value = data.get(key, default)
-    if isinstance(value, bool) or not isinstance(value, (int, float)):
-        raise ValueError(f"{key} must be a number")
-    return float(value)
-
-
-def _validate_ranges(
-    max_input_bytes: int,
-    min_savings_bytes: int,
-    min_savings_ratio: float,
-    ttl_minutes: int,
-    max_session_bytes: int,
-) -> None:
-    if not 1 <= max_input_bytes <= DEFAULT_MAX_INPUT_BYTES:
-        raise ValueError("maxInputBytes is outside the safe range")
-    if not 0 <= min_savings_bytes <= max_input_bytes:
-        raise ValueError("minSavingsBytes is outside the safe range")
-    if not 0.0 <= min_savings_ratio <= 1.0:
-        raise ValueError("minSavingsRatio is outside the safe range")
-    if ttl_minutes <= 0 or max_session_bytes <= 0:
-        raise ValueError("recovery limits must be positive")
-
-
-def load_policy(path: str | os.PathLike[str]) -> OutputFilterPolicy:
-    """Load an unwrapped, materialized policy object."""
-
-    with open(path, encoding="utf-8") as policy_file:
-        data = json.load(policy_file)
-    if not isinstance(data, dict):
-        raise ValueError("output-filter policy must be an object")
-    if set(data) - _TOP_LEVEL_KEYS:
-        raise ValueError("output-filter policy contains unknown keys")
-    mode = FilterMode(data["mode"])
-    raw_profiles = data.get("profiles", [])
-    if not isinstance(raw_profiles, list) or not all(
-        isinstance(profile, str) for profile in raw_profiles
-    ):
-        raise ValueError("profiles must be a string array")
-    if len(set(raw_profiles)) != len(raw_profiles):
-        raise ValueError("profiles must not contain duplicates")
-    if any(profile not in _KNOWN_PROFILES for profile in raw_profiles):
-        raise ValueError("profiles contains an unknown profile")
-    recovery = data.get("recovery", {})
-    if not isinstance(recovery, dict):
-        raise ValueError("recovery must be an object")
-    if set(recovery) - _RECOVERY_KEYS:
-        raise ValueError("recovery contains unknown keys")
-    if recovery.get("mode", "ephemeral") != "ephemeral":
-        raise ValueError("only ephemeral recovery is supported")
-    max_input_bytes = _integer(
-        data,
-        "maxInputBytes",
-        DEFAULT_MAX_INPUT_BYTES,
-    )
-    min_savings_bytes = _integer(
-        data,
-        "minSavingsBytes",
-        DEFAULT_MIN_SAVINGS_BYTES,
-    )
-    min_savings_ratio = _number(
-        data,
-        "minSavingsRatio",
-        DEFAULT_MIN_SAVINGS_RATIO,
-    )
-    ttl_minutes = _integer(recovery, "ttlMinutes", DEFAULT_TTL_MINUTES)
-    max_session_bytes = _integer(
-        recovery,
-        "maxSessionBytes",
-        DEFAULT_MAX_SESSION_BYTES,
-    )
-    _validate_ranges(
-        max_input_bytes,
-        min_savings_bytes,
-        min_savings_ratio,
-        ttl_minutes,
-        max_session_bytes,
-    )
-    return OutputFilterPolicy(
-        mode=mode,
-        profiles=tuple(raw_profiles),
-        max_input_bytes=max_input_bytes,
-        min_savings_bytes=min_savings_bytes,
-        min_savings_ratio=min_savings_ratio,
-        ttl_minutes=ttl_minutes,
-        max_session_bytes=max_session_bytes,
-    )

package/scripts/tool_output_filter/profiles/__init__.py

@@ -1,68 +0,0 @@
-"""Built-in deterministic output profiles."""
-
-from .repeat_lines import PROFILE_ID as REPEAT_LINES_ID
-from .repeat_lines import PROFILE_VERSION as REPEAT_LINES_VERSION
-from .repeat_lines import transform as transform_repeat_lines
-from .tap_success import PROFILE_ID as TAP_SUCCESS_ID
-from .tap_success import PROFILE_VERSION as TAP_SUCCESS_VERSION
-from .tap_success import transform as transform_tap_success
-
-
-class ProfileTransform:
-    __slots__ = ("accepted", "output", "profile_id", "profile_version")
-
-    def __init__(
-        self,
-        profile_id: str,
-        profile_version: int,
-        output: str,
-        accepted: bool,
-    ) -> None:
-        self.profile_id = profile_id
-        self.profile_version = profile_version
-        self.output = output
-        self.accepted = accepted
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, ProfileTransform):
-            return NotImplemented
-        return (
-            self.profile_id == other.profile_id
-            and self.profile_version == other.profile_version
-            and self.output == other.output
-            and self.accepted == other.accepted
-        )
-
-
-def apply_profile(
-    profile_id: str,
-    output: str,
-) -> ProfileTransform | None:
-    if profile_id == REPEAT_LINES_ID:
-        return ProfileTransform(
-            profile_id,
-            REPEAT_LINES_VERSION,
-            transform_repeat_lines(output),
-            True,
-        )
-    if profile_id == TAP_SUCCESS_ID:
-        transformed = transform_tap_success(output)
-        return ProfileTransform(
-            profile_id,
-            TAP_SUCCESS_VERSION,
-            transformed if transformed is not None else output,
-            transformed is not None,
-        )
-    return None
-
-
-__all__ = [
-    "ProfileTransform",
-    "REPEAT_LINES_ID",
-    "REPEAT_LINES_VERSION",
-    "TAP_SUCCESS_ID",
-    "TAP_SUCCESS_VERSION",
-    "apply_profile",
-    "transform_repeat_lines",
-    "transform_tap_success",
-]

package/scripts/tool_output_filter/profiles/repeat_lines.py

@@ -1,71 +0,0 @@
-"""Compact adjacent identical output lines."""
-
-from __future__ import annotations
-
-PROFILE_ID = "repeat-lines"
-PROFILE_VERSION = 1
-
-_DIAGNOSTIC_PREFIXES = (
-    "error",
-    "warning",
-    "warn:",
-    "fatal",
-    "fail",
-    "not ok",
-    "npm err!",
-    "critical",
-    "segmentation fault",
-    "traceback",
-    "exception",
-    "panic",
-    "assert",
-    "e   ",
-    "✕",
-    "✗",
-    "security",
-    "vulnerab",
-    "cve-",
-    "denied",
-    "unauthor",
-    "permission",
-)
-
-
-def _is_diagnostic(line: str) -> bool:
-    if not line.strip():
-        return True
-    stripped = line.lstrip().lower()
-    return (
-        stripped.startswith(_DIAGNOSTIC_PREFIXES)
-        or stripped.startswith("#")
-        or stripped.startswith("[ai-toolkit-output-filter ")
-        or "\x1b" in line
-        or "\x00" in line
-    )
-
-
-def transform(output: str) -> str:
-    """Collapse adjacent identical lines while preserving their first copy."""
-
-    lines = output.splitlines(keepends=True)
-    if not lines:
-        return output
-
-    transformed: list[str] = []
-    index = 0
-    while index < len(lines):
-        line = lines[index]
-        run_end = index + 1
-        while run_end < len(lines) and lines[run_end] == line:
-            run_end += 1
-        run_length = run_end - index
-        transformed.append(line)
-        if run_length > 1 and not _is_diagnostic(line):
-            transformed.append(
-                "[ai-toolkit-output-filter repeat-lines/v1: "
-                f"{run_length - 1} adjacent copies omitted]\n"
-            )
-        elif run_length > 1:
-            transformed.extend(lines[index + 1 : run_end])
-        index = run_end
-    return "".join(transformed)

package/scripts/tool_output_filter/profiles/tap_success.py

@@ -1,154 +0,0 @@
-"""Conservative compaction for valid, fully successful TAP output."""
-
-from __future__ import annotations
-
-PROFILE_ID = "tap-success"
-PROFILE_VERSION = 1
-
-_DIAGNOSTIC_COMMENT_PREFIXES = (
-    "# error",
-    "# stack",
-    "# message",
-    "# operator",
-    "# expected",
-    "# actual",
-    "# severity",
-    "# at ",
-)
-
-
-def _line_ending(lines: list[str]) -> str:
-    for line in lines:
-        if line.endswith("\r\n"):
-            return "\r\n"
-        if line.endswith("\n"):
-            return "\n"
-    return "\n"
-
-
-def _parse_plan(line: str) -> int | None:
-    content = line.strip()
-    if not content.startswith("1.."):
-        return None
-    count_text = content[3:].split("#", 1)[0].strip()
-    if not count_text.isdecimal():
-        return None
-    return int(count_text)
-
-
-def _parse_ok_number(line: str) -> tuple[int, bool] | None:
-    content = line.strip()
-    if not content.startswith("ok "):
-        return None
-    remainder = content[3:]
-    number_text = remainder.split(maxsplit=1)[0]
-    if not number_text.isdecimal():
-        return None
-    has_directive = False
-    if "#" in content:
-        directive = content.rsplit("#", 1)[1].strip().upper()
-        if not directive.startswith(("SKIP", "TODO")):
-            return None
-        has_directive = True
-    return int(number_text), has_directive
-
-
-def _has_nonzero_failure_summary(content: str) -> bool:
-    lowered = content.lower()
-    for prefix in ("# fail", "# cancel"):
-        if not lowered.startswith(prefix):
-            continue
-        remainder = lowered[len(prefix):]
-        # Accept spelling variants ("# failed", "# failures:") but treat any
-        # non-zero or unparseable count as a failure signal.
-        value = remainder.lstrip("abcdefghijklmnopqrstuvwxyz").strip(" :\t")
-        return not value.isdecimal() or int(value) != 0
-    return False
-
-
-def _parse_success_summary(content: str) -> tuple[str, int] | None:
-    lowered = content.lower()
-    for name in ("tests", "pass"):
-        prefix = f"# {name} "
-        if not lowered.startswith(prefix):
-            continue
-        value = lowered[len(prefix):].strip()
-        return name, int(value) if value.isdecimal() else -1
-    return None
-
-
-def transform(output: str) -> str | None:
-    """Return compact TAP, or ``None`` when the stream is not strictly safe."""
-
-    lines = output.splitlines(keepends=True)
-    if not lines or any(
-        "[ai-toolkit-output-filter " in line for line in lines
-    ):
-        return None
-
-    plan_count: int | None = None
-    result_numbers: list[int] = []
-    summary_counts: dict[str, int] = {}
-    omitted_count = 0
-    transformed: list[str] = []
-    newline = _line_ending(lines)
-
-    def flush_omitted() -> None:
-        nonlocal omitted_count
-        if omitted_count:
-            transformed.append(
-                "[ai-toolkit-output-filter tap-success/v1: "
-                f"{omitted_count} successful result lines omitted]"
-                f"{newline}"
-            )
-            omitted_count = 0
-
-    for line in lines:
-        content = line.strip()
-        if content == "TAP version 13":
-            flush_omitted()
-            transformed.append(line)
-            continue
-        parsed_plan = _parse_plan(line)
-        if parsed_plan is not None:
-            if plan_count is not None:
-                return None
-            plan_count = parsed_plan
-            flush_omitted()
-            transformed.append(line)
-            continue
-        parsed_ok = _parse_ok_number(line)
-        if parsed_ok is not None:
-            number, has_directive = parsed_ok
-            result_numbers.append(number)
-            if has_directive:
-                flush_omitted()
-                transformed.append(line)
-            else:
-                omitted_count += 1
-            continue
-        if content.lower().startswith(_DIAGNOSTIC_COMMENT_PREFIXES):
-            return None
-        if _has_nonzero_failure_summary(content):
-            return None
-        parsed_summary = _parse_success_summary(content)
-        if parsed_summary is not None:
-            name, value = parsed_summary
-            if value < 0 or name in summary_counts:
-                return None
-            summary_counts[name] = value
-        if not content or content.startswith("#"):
-            flush_omitted()
-            transformed.append(line)
-            continue
-        return None
-
-    flush_omitted()
-    if (
-        plan_count is None
-        or plan_count == 0
-        or result_numbers != list(range(1, plan_count + 1))
-        or any(count != plan_count for count in summary_counts.values())
-    ):
-        return None
-    return "".join(transformed)