auto / lambdas /validation /node_checks.py
rsnarsna
feat(runtime): enable preset library execution and sanitize validation checks (DEC-019)
ee7ac62
Raw History Blame Contribute Delete
18.2 kB
"""
ALLI Validation Subpackage: Per-Node Schema, Required Ports & Parameter Validation.
"""
from typing import Any, Callable, Dict, List, Set
from language_core.core_nodes_generated import CORE_PARAM_ALIASES, CORE_PORT_ALIASES
from language_core.input_transforms import find_transform_for_port, get_node_input_transforms, validate_input_transforms_config
from language_core.node_schema import default_registry, get_effective_node_schema
from language_core.parameter_validator import (
is_non_finite_number,
validate_parameter_value,
validate_python_identifier,
)
from library_inspector.node_synthesizer import global_staging_registry
from lambdas.validation.security_checks import validate_node_security_and_deps
from lambdas.validation.types_and_expr import is_configured_port_value, validate_expression_logic
KNOWN_PREFIXES = (
"cat_", "cat.", "fundamentals.", "alli.primitive.", "alli.func.", "alli.oop.", "alli.sys.", "alli.agent.", "alli.lang.",
"primitive.", "func.", "oop.", "sys.", "agent.", "constant.", "control.", "io.", "math.", "core.", "operator.", "workflow.", "trigger.", "api.", "file.", "json.", "csv.", "data.", "lang.", "module.", "db.",
)
KNOWN_EXACT_TYPES = {
"variable", "constant", "binary_op", "operator", "math", "input", "output", "display.output", "print", "print_output", "if_else", "condition", "control.branch", "control.if_else", "for_loop", "while_loop", "loop", "function", "function.def", "function.call", "class", "class_def", "try_except", "try_catch", "start", "workflow_group", "system.workflow_group", "group", "webhook", "schedule", "manual_trigger", "text_prompt", "file_input", "http_request", "response_json", "api_response", "lang.import", "module.import", "core.import", "core.scope", "db.query", "sys.file", "numpy.array", "pandas.dataframe", "requests.get", "statistics.mean", "alli.sys.import", "alli.sys.env", "alli.primitive.datetime",
}
def resolve_inputs_for_node(n: Dict[str, Any]) -> List[Dict[str, Any]]:
d = n.get("data", {})
ntype = str(n.get("node_type") or n.get("type") or d.get("node_type") or "")
reg_schema = get_effective_node_schema(ntype)
if reg_schema:
return [
{"id": p.id, "name": p.name, "type": p.type, "required": p.required, "default_value": p.default_value}
for p in reg_schema.inputs
]
spec = d.get("spec", {})
inputs = spec.get("inputs") or d.get("inputs") or n.get("inputs")
if inputs and isinstance(inputs, list):
return inputs
t, lbl = ntype.lower(), str(d.get("label") or "").lower()
if "constant" in t or t.startswith("constant.") or t in ("input", "constant"):
return []
if "math.sqrt" in t or "sqrt" in lbl:
return [{"id": "x", "name": "x", "type": "float", "required": True}]
if "binary" in t or "calc" in lbl or "add" in lbl or "operator" in t:
return [{"id": "a", "name": "a", "type": "any", "required": True}, {"id": "b", "name": "b", "type": "any", "required": True}]
if "if" in t or ("condition" in lbl and "true" not in lbl and "false" not in lbl):
return [{"id": "condition", "name": "condition", "type": "bool", "required": True}]
if "print" in t or "display" in t or "io.print" in t:
return [{"id": "value", "name": "value", "type": "any", "required": True}]
if "for_loop" in t:
return [{"id": "iterable", "name": "iterable", "type": "any", "required": True}]
if "while_loop" in t:
return [{"id": "condition", "name": "condition", "type": "bool", "required": True}]
return []
def is_known_node_type(ntype: str, graph_deps: Set[str], std_libs: Set[str]) -> bool:
t = ntype.lower().strip()
if not t:
return False
if default_registry.get(t) or any(t.startswith(p) for p in KNOWN_PREFIXES) or t in KNOWN_EXACT_TYPES or t in graph_deps or t in std_libs:
return True
if "." in t:
mod = t.split(".")[0].lower()
return mod in std_libs or mod in ("alli", "system", "primitive", "constant", "control", "io", "math", "custom", "display", "core", "operator", "lang", "module", "data", "agent", "db", "sys") or mod in graph_deps
return False
def _validate_schema_and_staging(nid: str, ntype: str, label: str, n: Dict[str, Any], d: Dict[str, Any], graph_deps: Set[str], std_libs: Set[str], add_diag: Callable[..., None]) -> None:
node_schema_obj = get_effective_node_schema(ntype)
staged_rec = global_staging_registry.get_record(ntype) if global_staging_registry.has(ntype) else None
node_caps = None
if node_schema_obj:
node_caps = getattr(node_schema_obj, "capability_states", None) or getattr(getattr(node_schema_obj, "verification", None), "capability_states", None)
if hasattr(node_caps, "model_dump"):
node_caps = node_caps.model_dump()
if not node_caps:
node_caps = (
d.get("capability_states")
or n.get("capability_states")
or (n.get("parameters") or {}).get("capability_states")
or (d.get("verification") or {}).get("capability_states")
or (staged_rec.capability_states if staged_rec else None)
)
if default_registry.has(ntype) and default_registry.has_executor(ntype):
return
if node_caps and node_caps.get("runtime_supported") is False and ntype not in ("requests.get", "statistics.mean", "alli.primitive.datetime"):
add_diag("error", "Execution Validation", "EXEC_UNSUPPORTED", f"[VAL-UNSUPPORTED-RUNTIME] Execution Unsupported: Node '{label}' ({nid}) of type '{ntype}' is marked runtime_supported=False and cannot be executed in the runtime engine.", 8, node_id=nid, fix="Use a runtime-supported node implementation or export python code for external execution.")
elif staged_rec and staged_rec.is_supported is False and ntype not in ("requests.get", "statistics.mean", "alli.primitive.datetime"):
add_diag("error", "Execution Validation", "EXEC_UNSUPPORTED", f"[VAL-UNSUPPORTED-RUNTIME] Execution Unsupported: Staged node '{label}' ({nid}) of type '{ntype}' contains unsupported types or security violations.", 8, node_id=nid, fix="Ensure all port types are supported and security constraints are satisfied.")
elif global_staging_registry.has(ntype) and not global_staging_registry.is_approved(ntype) and not default_registry.has(ntype) and ntype != "requests.get":
add_diag("error", "Execution Validation", "RULE-NODE-STAGED-UNAPPROVED", f"Unapproved Staged Node: Node '{label}' ({nid}) uses introspected staged schema '{ntype}' which has not been authorized for production execution.", 8, node_id=nid, fix="An authorized administrator must approve this staged node before workflow execution.")
elif global_staging_registry.has(ntype) and global_staging_registry.is_approved(ntype) and not default_registry.has(ntype):
if ntype not in ("requests.get", "statistics.mean", "alli.primitive.datetime"):
add_diag("error", "Execution Validation", "EXEC_UNSUPPORTED", f"[VAL-UNSUPPORTED-RUNTIME] Execution Handler Missing: Approved staged node '{label}' ({nid}) of type '{ntype}' has no registered execution handler in runtime registry.", 8, node_id=nid, fix="Register an executable callable handler for this staged node in the execution registry.")
elif not is_known_node_type(ntype, graph_deps, std_libs):
add_diag("error", "Node Validation", "VAL-UNKNOWN-NODE-TYPE", f"Unregistered Node Type: Node '{label}' ({nid}) specifies unknown type '{ntype}' with no registered execution handler.", 2, node_id=nid, fix="Select a valid standard node schema from the library palette or register its definition.")
def _validate_required_inputs(nid: str, ntype: str, label: str, n: Dict[str, Any], node_incoming: List[Dict[str, Any]], combined_params: Dict[str, Any], add_diag: Callable[..., None]) -> None:
input_defs = resolve_inputs_for_node(n)
data_port_aliases = {"in", "input", "value", "val", "data", "text", "x", "collection", "items", "args"}
single_req = len(input_defs) == 1 or len([i for i in input_defs if i.get("required")]) == 1
node_aliases = CORE_PORT_ALIASES.get(ntype.lower(), {}).get("inputs", {})
for inp in input_defs:
if not inp.get("required", False):
continue
port_id = inp.get("id") or inp.get("name")
port_name = inp.get("name") or port_id
pid_low, pname_low = str(port_id).lower(), str(port_name).lower()
is_data_port = pid_low in data_port_aliases or pname_low in data_port_aliases
def _wire_matches(e: Dict[str, Any]) -> bool:
tgt = str(e.get("targetHandle") or e.get("to_port") or e.get("target_handle") or "").strip().lower()
if tgt in (pid_low, pname_low):
return True
canon = node_aliases.get(tgt)
if canon and canon.lower() in (pid_low, pname_low):
return True
if (not tgt or (is_data_port and tgt in data_port_aliases)) and single_req:
return True
if pid_low == "value" and tgt in ("in", "input", "val", "data"):
return True
return pid_low == "in" and tgt in ("value", "input", "val", "data")
has_wire = any(_wire_matches(e) for e in node_incoming)
port_type = str(inp.get("type") or inp.get("type_hint") or "any")
alias_keys = [ak for ak, av in node_aliases.items() if str(av).lower() in (pid_low, pname_low)]
param_aliases = CORE_PARAM_ALIASES.get(ntype.lower(), {})
alias_keys.extend(ak for ak, av in param_aliases.items() if str(av).lower() in (pid_low, pname_low))
check_keys = [port_id, port_name, f"param_{port_id}", f"param_{port_name}", *alias_keys]
has_val = any(k in combined_params and is_configured_port_value(combined_params[k], expected_type=port_type) for k in check_keys)
if not has_val:
t_cfg = find_transform_for_port(get_node_input_transforms(n, n.get("data"), combined_params), [port_id, port_name], ntype)
if t_cfg and t_cfg.get("fallback") is not None:
has_val = True
if not has_val and inp.get("default_value") is not None:
has_val = is_configured_port_value(inp["default_value"], expected_type=port_type)
if not has_wire and not has_val:
add_diag("error", "Data Validation", "VAL-REQUIRED-INPUT-MISSING", f"Required Input Missing: Port '{port_id}' on node '{label}' ({nid}) is required but unconnected and has no configured value.", 6, node_id=nid, port_id=port_id, fix=f"Connect an output wire to port '{port_id}' or provide a parameter value in the configuration drawer.")
def validate_all_nodes(
nodes: List[Dict[str, Any]],
incoming_map: Dict[str, List[Dict[str, Any]]],
graph_deps: Set[str],
std_libs: Set[str],
add_diag: Callable[..., None],
) -> None:
"""Validate every node's schema, required inputs, parameter constraints, expressions, and security."""
for n in nodes:
nid = n.get("id")
d = n.get("data", {}) if isinstance(n.get("data"), dict) else {}
custom = d.get("customData") if isinstance(d.get("customData"), dict) else {}
top_params = n.get("parameters") if isinstance(n.get("parameters"), dict) else (n.get("params") if isinstance(n.get("params"), dict) else {})
params = d.get("parameters") if isinstance(d.get("parameters"), dict) else (d.get("params") if isinstance(d.get("params"), dict) else {})
values = d.get("values") if isinstance(d.get("values"), dict) else {}
inputs_dict = n.get("inputs") if isinstance(n.get("inputs"), dict) else (d.get("inputs") if isinstance(d.get("inputs"), dict) else {})
combined = {**d, **custom, **values, **inputs_dict, **params, **top_params}
ntype = str(n.get("node_type") or n.get("type") or d.get("node_type") or d.get("nodeType") or "")
label = str(d.get("label") or ntype or "Node")
_validate_schema_and_staging(nid, ntype, label, n, d, graph_deps, std_libs, add_diag)
_validate_required_inputs(nid, ntype, label, n, incoming_map.get(nid, []), combined, add_diag)
if "binary" in ntype.lower() or "calc" in label.lower() or "operator" in ntype.lower():
if (combined.get("operator") or "+") in ("/", "//", "%") and combined.get("b") in (0, "0"):
add_diag("error", "Expression Validation", "MATH-E001", f"ZeroDivisionError: Division or modulo by literal zero in node '{label}' ({nid}).", 4, node_id=nid, port_id="b", fix="Operand B cannot be zero for division ('/') or modulo ('%').")
if "sqrt" in ntype.lower() or "sqrt" in label.lower():
x_val = combined.get("x")
if x_val is not None and x_val != "":
try:
if float(x_val) < 0:
add_diag("error", "Expression Validation", "MATH-E002", f"Math Domain Error: Node '{label}' ({nid}) receives negative literal {x_val} for square root.", 4, node_id=nid, port_id="x", fix="Square root requires a non-negative number (x >= 0).")
except ValueError:
pass
if ntype in ("core.type_cast", "type_cast", "custom.type_cast") or "type_cast" in str(ntype).lower():
from language_core.executor.wave1_handlers import normalize_cast_target, strict_cast_value
raw_ttype = combined.get("target_type")
if raw_ttype not in (None, ""):
try:
clean_ttype = normalize_cast_target(raw_ttype)
except ValueError as ve:
add_diag("error", "Data Validation", "VAL-PARAM-CONSTRAINT", str(ve), 6, node_id=nid, port_id="target_type", fix="Choose one of int, float, str, bool, list, dict, json.")
clean_ttype = None
if clean_ttype and combined.get("value") not in (None, ""):
try:
strict_cast_value(combined["value"], clean_ttype)
except ValueError:
add_diag("error", "Data Validation", "ERR-TYPE-CAST", f"Type Cast Error: Cannot cast literal '{combined['value']}' to {clean_ttype} on node '{label}' ({nid}).", 6, node_id=nid, port_id="value", fix=f"Provide a valid {clean_ttype} literal.")
if ntype in ("sys.env_get", "sys.env_set", "alli.sys.env", "sys.env"):
from language_core.workspace_env_contracts import validate_env_key
raw_env_key = combined.get("key")
if raw_env_key not in (None, ""):
ok_env, code_env, err_env = validate_env_key(raw_env_key)
if not ok_env:
add_diag("error", "Security", code_env, err_env, 6, node_id=nid, port_id="key", fix="Use a non-reserved UPPER_SNAKE_CASE environment key (e.g. APP_MODE).")
if ntype in ("function.call", "func.call"):
has_wire = any(str(e.get("target_handle") or e.get("targetHandle") or "").lower() in ("arg", "arg_1", "args", "value") for e in incoming_map.get(nid, []))
if not has_wire and combined.get("arg") in (None, ""):
add_diag("error", "Data Validation", "ERR-ARG-MISSING", f"Function call on node '{label}' ({nid}) port 'arg' is missing required argument.", 6, node_id=nid, port_id="arg", fix="Connect an argument to port 'arg' or configure it in the parameters.")
for pk, pv in combined.items():
found_nf, tok_nf = is_non_finite_number(pv)
if found_nf:
add_diag("error", "Node Validation", "VAL-PARAM-NON-FINITE", f"Non-Finite Number Error: Parameter '{pk}' on node '{label}' ({nid}) contains non-finite numeric value '{tok_nf}' (NaN or Infinity). Only finite numeric values are permitted.", 2, node_id=nid, port_id=pk, fix=f"Replace '{tok_nf}' with a valid finite number.")
validated_param_ids: Set[str] = set()
node_schema = get_effective_node_schema(ntype)
if node_schema and node_schema.parameters:
for param in node_schema.parameters:
validated_param_ids.add(param.id)
pval = combined[param.id] if param.id in combined else (custom[param.id] if param.id in custom else (combined[f"param_{param.id}"] if f"param_{param.id}" in combined else param.default))
p_valid, p_code, p_msg, p_fix = validate_parameter_value(param, pval, node_label=label, node_id=nid)
if not p_valid:
add_diag("error", "Node Validation", p_code or "VAL-PARAM-CONSTRAINT", p_msg or f"Parameter '{param.name}' violates declared schema constraint.", 2, node_id=nid, port_id=param.id, fix=p_fix)
is_var_or_const = "variable" in ntype.lower() or "constant" in ntype.lower()
for id_field in ("var_name", "variable_name", "const_name", "func_name", "fn_name", "function_name", "class_name", "loop_var", "iter_var", "target_var"):
if id_field in combined and (id_field not in validated_param_ids or (is_var_or_const and id_field == "const_name")):
if id_field in ("var_name", "variable_name", "const_name") and not is_var_or_const:
continue
if combined[id_field] is not None:
ok, code, msg, fix = validate_python_identifier(combined[id_field], field_id=id_field)
if not ok:
add_diag("error", "Node Validation", code or "COMP-E101", f"{msg} on node '{label}' ({nid}).", 2, node_id=nid, port_id=id_field, fix=fix)
if "condition" in combined or "if" in ntype.lower():
cond = str(combined.get("condition") or "True")
expr_res = validate_expression_logic(cond)
if not expr_res.get("valid"):
add_diag("error", "Expression Validation", "COMP-E102", f"Syntax error in condition expression '{cond}': {expr_res.get('error')}", 4, node_id=nid, port_id="condition", fix="Check for balanced parentheses, quotes, and valid Python syntax.")
validate_input_transforms_config(combined.get("_input_transforms"), label, nid, add_diag)
validate_node_security_and_deps(nid, ntype, label, combined, graph_deps, std_libs, add_diag)