"""Portable declarations for agent methods, independent of a Python policy SDK. These are participant declarations, not provider identity or usage attestation. Configuration is explicitly public: never include credentials or private paths. """ from __future__ import annotations import math import re METHOD_SCHEMA = "starvla-rsi.method/v1" USAGE_ACCOUNTING_VERSION = "starvla-rsi.method-usage/v1" USAGE_FIELDS = ("calls", "input_tokens", "output_tokens", "cached_input_tokens", "estimated_cost_usd", "latency_s") _SECRET = {"password", "secret", "credentials", "authorization", "api_key", "apikey", "api_token", "access_token", "refresh_token", "bearer_token", "client_secret"} def _text(value, label, *, optional=False, identifier=False): if optional and value is None: return None if not isinstance(value, str) or not value.strip() or len(value) > 512: raise ValueError(f"invalid {label}") if any(ord(c) < 32 or 0xD800 <= ord(c) <= 0xDFFF for c in value): raise ValueError(f"invalid {label}") if identifier and re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,127}", value) is None: raise ValueError(f"invalid {label} identifier") if value.startswith(("/", "~/", "\\\\")) or re.match(r"^[A-Za-z]:[\\/]", value): raise ValueError(f"private path in {label}") return value def _configuration(value): remaining = 8192 def walk(item, depth=0): nonlocal remaining remaining -= 1 if remaining < 0 or depth > 8: raise ValueError("method configuration exceeds bounds") if item is None or type(item) in (bool, int): return item if type(item) is float and math.isfinite(item): return item if isinstance(item, str): if len(item) > 16384 or any(0xD800 <= ord(c) <= 0xDFFF for c in item): raise ValueError("invalid method configuration text") if item.startswith(("/", "~/", "\\\\")) or re.match(r"^[A-Za-z]:[\\/]", item): raise ValueError("private path in public method configuration") return item if type(item) is list: return [walk(child, depth + 1) for child in item] if type(item) is dict: out = {} for key, child in item.items(): if not isinstance(key, str) or not key or len(key) > 128: raise ValueError("invalid method configuration key") lowered = key.lower().replace("-", "_") if lowered in _SECRET or any(lowered.endswith("_" + name) for name in _SECRET): raise ValueError("credential field in public method configuration") out[key] = walk(child, depth + 1) return out raise ValueError("method configuration must be finite JSON") if type(value) is not dict: raise ValueError("method configuration must be an object") return walk(value) def normalize_method(value): """Validate a public method declaration; reject undeclared top-level fields.""" if type(value) is not dict or set(value) - {"schema_version", "id", "version", "models", "configuration"}: raise ValueError("invalid method declaration fields") if value.get("schema_version") != METHOD_SCHEMA: raise ValueError("unsupported method schema") models = value.get("models") if type(models) is not list or len(models) > 64: raise ValueError("method models must be a bounded list") normalized = [] for row in models: if type(row) is not dict or set(row) - {"id", "role", "provider", "model", "version"}: raise ValueError("invalid model component fields") normalized.append({"id": _text(row.get("id"), "component ID", identifier=True), "role": _text(row.get("role"), "component role"), **{key: _text(row.get(key), "component " + key, optional=True) for key in ("provider", "model", "version")}}) if len({row["id"] for row in normalized}) != len(normalized): raise ValueError("duplicate method model component") return {"schema_version": METHOD_SCHEMA, "id": _text(value.get("id"), "method ID"), "version": _text(value.get("version"), "method version", optional=True), "models": normalized, "configuration": _configuration(value.get("configuration", {}))} def method_from_policy(descriptor): """Preserve legacy declarations without guessing a provider/model/configuration.""" policy = descriptor.to_dict() if hasattr(descriptor, "to_dict") else descriptor if type(policy) is not dict: raise ValueError("policy descriptor must be an object") models = [] if policy.get("model") is not None or policy.get("provider") is not None: models = [{"id": "primary", "role": "policy", "model": policy.get("model"), "provider": policy.get("provider"), "version": None}] return normalize_method({"schema_version": METHOD_SCHEMA, "id": policy.get("name"), "version": policy.get("version"), "models": models, "configuration": {}}) def normalize_usage(value): """Missing fields are unavailable, never implicitly zero.""" if value is None: value = {} if type(value) is not dict or set(value) - set(USAGE_FIELDS): raise ValueError("invalid component usage fields") out = {} for key in USAGE_FIELDS: number = value.get(key) kinds = (int,) if key in USAGE_FIELDS[:4] else (int, float) if number is not None and (type(number) not in kinds or number < 0 or type(number) is float and not math.isfinite(number) or type(number) is int and number > 2**63 - 1): raise ValueError("invalid component usage value") out[key] = number if (out["cached_input_tokens"] is not None and out["input_tokens"] is not None and out["cached_input_tokens"] > out["input_tokens"]): raise ValueError("cached input tokens exceed input tokens") return out def normalize_component_usage(value, method): """Map declared IDs to reported usage; every absent component stays unknown.""" ids = [row["id"] for row in normalize_method(method)["models"]] if value is None: value = {} if type(value) is not dict or set(value) - set(ids): raise ValueError("usage names an undeclared model component") return {identifier: normalize_usage(value.get(identifier)) for identifier in ids} def sum_component_usage(left, right, method): """Sum declared component ledgers with unknown propagation, not allocation.""" left, right = normalize_component_usage(left, method), normalize_component_usage(right, method) return {identifier: {key: None if left[identifier][key] is None or right[identifier][key] is None else left[identifier][key] + right[identifier][key] for key in USAGE_FIELDS} for identifier in left}