parameter_normalization.py

from __future__ import annotations

from collections.abc import Mapping, Sequence
from pathlib import PurePath
import re
from typing import Any
from urllib.parse import urlparse


_UUID_RE = re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$")
_HASH_RE = re.compile(r"^[0-9a-fA-F]{16,}$")
_TIMESTAMP_RE = re.compile(
    r"^(?:\d{4}-\d{2}-\d{2}(?:[T ][0-9:.+-Z]+)?|\d{10,13})$"
)
_WINDOWS_PATH_RE = re.compile(r"^[A-Za-z]:[\\/]")
_RANDOM_ID_RE = re.compile(r"^(?:[A-Za-z]+[_-])?[0-9a-fA-F]{8,}$")
_SAFE_ENUM_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_.-]{0,31}$")
_URL_SCHEME_RE = re.compile(r"^(?:https?|ftp|s3|gs)://", re.IGNORECASE)


def _looks_like_path(value: str) -> bool:
    if _WINDOWS_PATH_RE.match(value):
        return True
    return value.startswith(("/", "./", "../", "~/")) or ("/" in value and " " not in value)


def _path_token(value: str) -> str:
    cleaned = value.replace("\\", "/")
    suffix = PurePath(cleaned).suffix.lower()
    suffix_token = suffix if suffix and len(suffix) <= 10 else ""
    scope = "ABS" if cleaned.startswith("/") or _WINDOWS_PATH_RE.match(value) else "REL"
    if any(part.lower() in {"tmp", "temp", "cache"} for part in cleaned.split("/")):
        scope = "TEMP"
    return f"<PATH:{scope}{':' + suffix_token if suffix_token else ''}>"


def normalize_parameter_value(value: Any, config: dict[str, Any] | None = None) -> str:
    config = config or {}
    keep_enums = bool(config.get("keep_stable_enum_values", True))
    if value is None:
        return "<NULL>"
    if isinstance(value, bool):
        return "<BOOL:TRUE>" if value else "<BOOL:FALSE>"
    if isinstance(value, int) and not isinstance(value, bool):
        if bool(config.get("keep_small_integers", True)) and -10 <= value <= 100:
            return f"<INT:{value}>"
        magnitude = "SMALL" if abs(value) < 1_000 else "MEDIUM" if abs(value) < 1_000_000 else "LARGE"
        return f"<INT:{magnitude}>"
    if isinstance(value, float):
        return "<FLOAT>"
    if isinstance(value, Mapping):
        return "<OBJECT>"
    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
        return f"<LIST:{min(len(value), 20)}>"
    if isinstance(value, (bytes, bytearray)):
        return f"<BYTES:{len(value)}>"

    text = str(value).strip()
    if not text:
        return "<EMPTY>"
    if _UUID_RE.match(text):
        return "<UUID>"
    if _TIMESTAMP_RE.match(text):
        return "<TIMESTAMP>"
    if _HASH_RE.match(text):
        return "<HASH>"
    # ``urllib.parse.urlparse`` may raise ``ValueError: Invalid IPv6 URL``
    # for arbitrary tool arguments containing unmatched square brackets.  Most
    # parameter values are not URLs, so only invoke the parser when a supported
    # URL scheme is explicitly present.  Malformed URL-like values are mapped to a typed placeholder instead of
    # aborting feature construction.
    if _URL_SCHEME_RE.match(text):
        try:
            parsed = urlparse(text)
        except ValueError:
            return "<URL:MALFORMED>"
        if parsed.scheme.lower() in {"http", "https", "ftp", "s3", "gs"}:
            kind = parsed.scheme.upper()
            suffix = PurePath(parsed.path).suffix.lower()
            return f"<URL:{kind}{':' + suffix if suffix else ''}>"
    if _looks_like_path(text):
        return _path_token(text)
    if _RANDOM_ID_RE.match(text) and any(char.isdigit() for char in text):
        return "<ID>"
    if keep_enums and _SAFE_ENUM_RE.match(text) and len(text) <= int(config.get("max_enum_length", 32)):
        return text.lower()
    if text.isdigit():
        return "<NUMBER>"
    return "<TEXT>"


def flatten_parameters(value: Any, prefix: str = "arg", *, max_items: int = 64) -> list[tuple[str, Any]]:
    output: list[tuple[str, Any]] = []

    def visit(current: Any, path: str) -> None:
        if len(output) >= max_items:
            return
        if isinstance(current, Mapping):
            for key in sorted(current, key=lambda item: str(item)):
                visit(current[key], f"{path}.{key}")
            return
        if isinstance(current, Sequence) and not isinstance(current, (str, bytes, bytearray)):
            output.append((path, current))
            for index, item in enumerate(current[:5]):
                if isinstance(item, (Mapping, list, tuple)):
                    visit(item, f"{path}[]")
            return
        output.append((path, current))

    visit(value, prefix)
    return output


def normalized_call_tokens(
    tool_name: str,
    tool_input: Any,
    config: dict[str, Any] | None = None,
) -> tuple[str, list[str]]:
    """Return a normalized call signature and argument-role tokens.

    Raw paths, filenames, UUIDs, timestamps and random IDs are replaced with
    typed placeholders. Argument keys and stable enum values are retained because
    they often carry the discriminative semantics missing from the tool name.
    """
    config = config or {}
    tool = str(tool_name or "unknown_tool").strip().lower()
    pairs = flatten_parameters(
        tool_input if tool_input is not None else {},
        max_items=int(config.get("max_flattened_items", 64)),
    )
    role_tokens: list[str] = []
    signature_parts: list[str] = []
    for key, value in pairs:
        try:
            normalized = normalize_parameter_value(value, config)
        except (TypeError, ValueError, UnicodeError):
            # A single malformed argument must not abort feature construction.
            # Keep its parameter role while discarding the unsafe raw value.
            normalized = "<TEXT>"
        safe_key = re.sub(r"[^A-Za-z0-9_.\[\]-]+", "_", key.lower())
        signature_parts.append(f"{safe_key}={normalized}")
        role_tokens.append(f"param:{tool}:{safe_key}={normalized}")
    if not signature_parts:
        signature_parts.append("<NO_ARGS>")
    signature = f"call:{tool}[{'|'.join(signature_parts)}]"
    return signature, role_tokens