File size: 10,813 Bytes
91a883e
 
8628c98
91a883e
 
 
8628c98
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
27c61c9
 
4992fbd
49be3fc
 
 
 
8628c98
 
 
 
 
 
 
52cd762
 
d893281
52cd762
 
 
8628c98
 
52cd762
 
 
 
 
49be3fc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
52cd762
 
 
 
 
 
 
 
09fcf7b
8628c98
 
49be3fc
 
 
 
 
 
 
52cd762
09fcf7b
49be3fc
 
 
 
 
 
 
 
 
8628c98
 
49be3fc
8628c98
4992fbd
52cd762
4992fbd
 
8628c98
 
4992fbd
8628c98
4992fbd
8628c98
 
4992fbd
 
 
8628c98
52cd762
 
 
8628c98
52cd762
49be3fc
 
 
 
 
2d8ecc2
 
49be3fc
8628c98
49be3fc
 
8628c98
49be3fc
 
 
52cd762
09fcf7b
49be3fc
8628c98
9621c05
8628c98
accc89a
8628c98
 
accc89a
8628c98
52cd762
 
 
 
 
 
8628c98
52cd762
49be3fc
 
 
 
8628c98
49be3fc
 
 
8628c98
49be3fc
8628c98
0dc8f9c
 
91a883e
 
 
 
 
49be3fc
8628c98
49be3fc
aff4feb
0dc8f9c
8628c98
aff4feb
91a883e
 
8628c98
91a883e
8628c98
91a883e
8628c98
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
"""
ALLI Lambda Function: Language Core Validator (alli-validate)
Facade orchestrating type compatibility, connection checks, graph validation, and Lambda dispatch.
"""

import json
from collections import defaultdict
from typing import Any, Dict, List, Optional

from language_core.node_schema import NodeDefinition, default_registry
from lambdas.validation.connection_validator import validate_connection_logic
from lambdas.validation.graph_checks import validate_graph_cycles, validate_graph_entrypoints
from lambdas.validation.metadata_validator import validate_node_metadata_logic
from lambdas.validation.node_checks import validate_all_nodes
from lambdas.validation.types_and_expr import (
    APPROVED_AGENT_TYPES,
    APPROVED_REASONER_TYPES,
    is_agent_reasoner_or_memory,
    is_approved_agent_node,
    is_configured_port_value,
    is_loop_header_node,
    is_valid_node_id,
    validate_expression_logic,
    validate_types_logic,
)

STD_LIBS = {
    "math", "json", "sys", "os", "re", "time", "datetime", "random",
    "collections", "itertools", "functools", "urllib", "typing", "string",
    "copy", "hashlib", "base64", "io", "pathlib", "subprocess", "logging",
    "shutil", "csv", "tempfile", "traceback", "struct", "unicodedata",
    "core", "operator",
}


def validate_workflow_protocol_logic(
    graph: Dict[str, Any],
    execution_exit_code: Optional[int] = None,
) -> Dict[str, Any]:
    """Phase 3.9: Complete 10-Possibility Workflow Validation Engine."""
    from language_core.workflow_migration import migrate_workflow
    if graph and isinstance(graph, dict):
        try:
            graph = migrate_workflow(graph)
        except Exception:
            pass

    raw_nodes = graph.get("nodes", [])
    raw_edges = graph.get("edges") if graph.get("edges") is not None else (graph.get("connections") or [])

    nodes = [
        n for n in raw_nodes
        if str(n.get("node_type") or n.get("type") or n.get("data", {}).get("node_type") or "")
        not in ("system.workflow_group", "workflow_group", "workflowGroup")
    ]
    edges = [
        e for e in raw_edges
        if not str(e.get("source", "")).startswith("group_") and not str(e.get("target", "")).startswith("group_")
    ]

    diagnostics: List[Dict[str, Any]] = []
    possibility_map = {
        "Start Validation": {"errors": 0, "warnings": 0, "summary": "Valid starter trigger"},
        "Node Validation": {"errors": 0, "warnings": 0, "summary": "Node parameters checked"},
        "Connection Validation": {"errors": 0, "warnings": 0, "summary": "Ports & topology verified"},
        "Control Flow": {"errors": 0, "warnings": 0, "summary": "Branch paths verified"},
        "Loop Validation": {"errors": 0, "warnings": 0, "summary": "Iteration & exit behavior checked"},
        "Data Validation": {"errors": 0, "warnings": 0, "summary": "Incoming data schema checked"},
        "Expression Validation": {"errors": 0, "warnings": 0, "summary": "AST expressions validated"},
        "Credential Validation": {"errors": 0, "warnings": 0, "summary": "Security and credentials verified"},
        "Dependency Validation": {"errors": 0, "warnings": 0, "summary": "Libraries & imports checked"},
        "Error Handling": {"errors": 0, "warnings": 0, "summary": "Failure handlers reviewed"},
        "Execution Validation": {"errors": 0, "warnings": 0, "summary": "Execution readiness checked"},
    }

    def add_diag(
        severity: str,
        category: str,
        code: str,
        msg: str,
        rule: int,
        node_id: Optional[str] = None,
        port_id: Optional[str] = None,
        edge_id: Optional[str] = None,
        fix: Optional[str] = None,
    ) -> None:
        diagnostics.append({
            "code": code,
            "severity": severity,
            "category": category,
            "rule_number": rule,
            "message": msg,
            "node_id": node_id,
            "port_id": port_id,
            "edge_id": edge_id,
            "fix_suggestion": fix,
        })
        if category in possibility_map:
            if severity == "error":
                possibility_map[category]["errors"] += 1
            elif severity == "warning":
                possibility_map[category]["warnings"] += 1

    if not nodes:
        add_diag("warning", "Start Validation", "VAL-001", "Canvas is empty. Add nodes to build a workflow.", 1, fix="Insert nodes via the library palette or context menu.")
        return {"valid": False, "status": "Warning", "can_execute": False, "error_count": 0, "warning_count": 1, "diagnostics": diagnostics, "possibilities": possibility_map}

    id_counts: Dict[str, int] = defaultdict(int)
    node_map: Dict[str, Dict[str, Any]] = {}
    for n in nodes:
        raw_id = n.get("id")
        lbl = str(n.get("data", {}).get("label") or n.get("node_type") or "Node")
        is_valid_id, err_code = is_valid_node_id(raw_id)
        if not is_valid_id:
            if err_code == "VAL-NODE-ID-EMPTY":
                add_diag("error", "Node Validation", "VAL-NODE-ID-EMPTY", f"Empty Node ID: Node '{lbl}' has a missing, null, or empty identifier. Every node must have a non-empty string ID.", 2, node_id="", fix="Assign a unique, non-empty identifier to each node in the workflow.")
            else:
                id_disp = str(raw_id) if raw_id is not None else ""
                add_diag("error", "Node Validation", "VAL-NODE-ID-MALFORMED", f"Malformed Node ID: Identifier '{id_disp}' on node '{lbl}' contains invalid characters, whitespace, or exceeds 128 characters. Allowed characters: alphanumeric, '_', '-', '.', ':', '#', '@', '/'.", 2, node_id=id_disp, fix="Use a valid alphanumeric identifier without whitespace, quotes, newlines, or illegal characters.")
            continue
        id_str = str(raw_id)
        id_counts[id_str] += 1
        node_map.setdefault(id_str, n)

    for nid, count in id_counts.items():
        if count > 1:
            add_diag("error", "Node Validation", "VAL-DUPLICATE-NODE-ID", f"Duplicate Node ID: Multiple nodes ({count}) share the identifier '{nid}'. Each node in the workflow must have a unique ID.", 2, node_id=nid, fix="Assign unique IDs to each node in the workflow.")

    incoming_map: Dict[str, List[Dict[str, Any]]] = {nid: [] for nid in node_map}
    outgoing_map: Dict[str, List[Dict[str, Any]]] = {nid: [] for nid in node_map}
    for edge in edges:
        src = edge.get("source") or edge.get("from_node")
        tgt = edge.get("target") or edge.get("to_node")
        src_port = edge.get("sourceHandle") or edge.get("from_port") or edge.get("source_handle") or "out"
        tgt_port = edge.get("targetHandle") or edge.get("to_port") or edge.get("target_handle") or "input"
        if src not in node_map:
            add_diag("error", "Connection Validation", "VAL-003", f"Broken Connection: Edge connects from nonexistent source node '{src}'.", 3, port_id=src_port, fix="Delete the broken connection wire.")
            continue
        if tgt not in node_map:
            add_diag("error", "Connection Validation", "VAL-004", f"Broken Connection: Edge connects to nonexistent target node '{tgt}'.", 3, port_id=tgt_port, fix="Delete the broken connection wire.")
            continue
        outgoing_map[src].append(edge)
        incoming_map[tgt].append(edge)
        conn_res = validate_connection_logic(edge, nodes_map=node_map, edges=edges, skip_cycle_check=True)
        edge_id = edge.get("id")
        if not conn_res.get("valid", True):
            add_diag("error", "Connection Validation", conn_res.get("code", "VAL-007"), conn_res.get("message", "Port connection validation failed."), 3, node_id=tgt, port_id=tgt_port, edge_id=edge_id, fix="Ensure compatible port types, avoid duplicate connections, and connect output to input.")
        elif conn_res.get("warning"):
            add_diag("warning", "Connection Typing", "WARN-CONV", conn_res["warning"], 1, node_id=tgt, port_id=tgt_port, edge_id=edge_id, fix="Verify runtime types match expected contract.")

    validate_graph_cycles(nodes, edges, node_map, add_diag)
    validate_graph_entrypoints(nodes, node_map, incoming_map, outgoing_map, add_diag)

    graph_deps = {str(d).lower() for d in (graph.get("dependencies") or [])}
    req_txt = graph.get("compiled_artifacts", {}).get("requirements_txt", "")
    for rline in req_txt.splitlines():
        pkg_cleaned = rline.strip().split("==")[0].split(">=")[0].split("<=")[0].strip().lower()
        if pkg_cleaned:
            graph_deps.add(pkg_cleaned)

    validate_all_nodes(nodes, incoming_map, graph_deps, STD_LIBS, add_diag)

    if execution_exit_code is not None:
        if execution_exit_code == 0:
            possibility_map["Execution Validation"]["summary"] = "Sandbox execution passed (Exit 0)."
        else:
            add_diag("error", "Execution Validation", "EXEC-E001", f"Execution failed with Exit Code {execution_exit_code}.", 8)

    errors = sum(p["errors"] for p in possibility_map.values())
    warnings = sum(p["warnings"] for p in possibility_map.values())
    status = "Runtime Error" if (execution_exit_code is not None and execution_exit_code != 0) else ("Error" if errors > 0 else ("Warning" if warnings > 0 else "Valid"))

    return {"valid": errors == 0, "status": status, "can_execute": errors == 0, "error_count": errors, "warning_count": warnings, "diagnostics": diagnostics, "possibilities": possibility_map}


def handler(event: Dict[str, Any], context: Any = None) -> Dict[str, Any]:
    """Standalone AWS Lambda handler entrypoint for alli-validate function."""
    try:
        body_raw = event.get("body", "{}")
        body = json.loads(body_raw) if isinstance(body_raw, str) else body_raw
        if "graph" in body or "graph_spec" in body:
            res = validate_workflow_protocol_logic(body.get("graph") or body.get("graph_spec"), execution_exit_code=body.get("execution_exit_code"))
        elif "expression" in body:
            res = validate_expression_logic(body["expression"])
        elif "node_metadata" in body or "node_definition" in body:
            res = validate_node_metadata_logic(body.get("node_metadata") or body.get("node_definition"))
        elif "connection" in body:
            res = validate_connection_logic(body["connection"], nodes_map=body.get("nodes_map"))
        else:
            res = validate_types_logic(body.get("source_type", "Any"), body.get("target_type", "Any"))

        return {"statusCode": 200, "headers": {"Content-Type": "application/json", "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "POST, OPTIONS"}, "body": json.dumps(res)}
    except Exception as err:
        return {"statusCode": 500, "headers": {"Content-Type": "application/json", "Access-Control-Allow-Origin": "*"}, "body": json.dumps({"error": str(err)})}