programgarden 1.23.1__tar.gz → 1.24.1__tar.gz

{programgarden-1.23.1 → programgarden-1.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.23.1
+Version: 1.24.1
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 Author: 프로그램동산
 Author-email: coding@programgarden.com
@@ -14,9 +14,9 @@ Requires-Dist: aiosqlite (>=0.20.0,<0.21.0)
 Requires-Dist: croniter (>=6.0.0,<7.0.0)
 Requires-Dist: litellm (>=1.40.0)
 Requires-Dist: lxml (>=6.0.2,<7.0.0)
-Requires-Dist: programgarden-community (>=1.13.8,<2.0.0)
-Requires-Dist: programgarden-core (>=1.14.5,<2.0.0)
-Requires-Dist: programgarden-finance (>=1.6.10,<2.0.0)
+Requires-Dist: programgarden-community (>=1.13.9,<2.0.0)
+Requires-Dist: programgarden-core (>=1.15.1,<2.0.0)
+Requires-Dist: programgarden-finance (>=1.6.11,<2.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)

{programgarden-1.23.1 → programgarden-1.24.1}/programgarden/__init__.py

@@ -14,6 +14,17 @@ from programgarden.executor import WorkflowExecutor
 from programgarden.context import ExecutionContext
 from programgarden.client import ProgramGarden
 from programgarden.node_runner import NodeRunner
+from programgarden.semantic_rules import (
+    analyze_workflow_semantics,
+    normalize_severities,
+    DEFAULT_SEMANTIC_SEVERITIES,
+    STRICT_SEMANTIC_SEVERITIES,
+    ALL_RULES,
+    RULE_ORDER_QTY_FROM_AI,
+    RULE_STRUCTURED_OUTPUT_NO_SCHEMA,
+    RULE_HARDCODED_ORDER_QTY,
+    RULE_ORDER_IGNORED_FIELD,
+)
 from programgarden_core.bases.listener import (
     NodeState,
     EdgeState,
@@ -140,4 +151,14 @@ __all__ = [
     "get_events",
     "get_job_summary",
     "analyze_performance",
+    # Semantic / safety layer (deep_validate R1~R4)
+    "analyze_workflow_semantics",
+    "normalize_severities",
+    "DEFAULT_SEMANTIC_SEVERITIES",
+    "STRICT_SEMANTIC_SEVERITIES",
+    "ALL_RULES",
+    "RULE_ORDER_QTY_FROM_AI",
+    "RULE_STRUCTURED_OUTPUT_NO_SCHEMA",
+    "RULE_HARDCODED_ORDER_QTY",
+    "RULE_ORDER_IGNORED_FIELD",
 ]

{programgarden-1.23.1 → programgarden-1.24.1}/programgarden/client.py

@@ -80,6 +80,7 @@ class ProgramGarden:
         *,
         fixtures: Optional[Dict[str, Any]] = None,
         timeout: float = 15.0,
+        semantic_rules: Optional[Dict[str, Any]] = None,
     ) -> ValidationResult:
         """Deep-validate a workflow via virtual full-execution (never raises).
 
@@ -96,6 +97,11 @@ class ProgramGarden:
             fixtures: Optional per-node fixture overrides, keyed by node id or
                 node type (merged shallowly on top of the default fixture).
             timeout: Hard timeout (seconds) for the single validation pass.
+            semantic_rules: Optional per-rule severity config for the configurable
+                semantic/safety layer (R1~R4). ``None`` (default) skips the layer;
+                pass ``programgarden.semantic_rules.STRICT_SEMANTIC_SEVERITIES`` (or
+                a ``{rule_id: "error"|"warning"|"off"}`` dict) to opt in. See
+                ``WorkflowExecutor.deep_validate`` for details.
 
         Returns:
             ValidationResult — ``errors`` carry structured per-node ErrorInfo;
@@ -109,7 +115,12 @@ class ProgramGarden:
             ...         print(err.short())
         """
         return _run_coro_sync(
-            self.executor.deep_validate(definition, fixtures=fixtures, timeout=timeout)
+            self.executor.deep_validate(
+                definition,
+                fixtures=fixtures,
+                timeout=timeout,
+                semantic_rules=semantic_rules,
+            )
         )
 
     def run(

{programgarden-1.23.1 → programgarden-1.24.1}/programgarden/deep_fixtures.py

@@ -361,6 +361,77 @@ def broker_connection_fixture(
     }
 
 
+def _schema_default_value(schema: Any) -> Any:
+    """Best-effort default value for one ``output_schema`` entry.
+
+    An entry is either a bare type string (``"number"``) or a JSON-schema-ish
+    dict (``{"type": "...", "enum": [...], "items": {...}, "properties": {...}}``)
+    — the two shapes ``AIAgentNodeExecutor._build_output_instruction`` /
+    ``_validate_structured`` already accept. Returns a type-correct placeholder
+    so a downstream ``{{ nodes.<agent>.response.<field> }}`` binding resolves to a
+    real value (an enum field resolves to its first allowed value, an object to
+    its declared properties, an array to a single shaped element).
+    """
+    if isinstance(schema, str):
+        type_name, spec = schema, {}
+    elif isinstance(schema, dict):
+        type_name, spec = str(schema.get("type", "string")), schema
+    else:
+        return "deep_validate"
+
+    enum_vals = spec.get("enum") if isinstance(spec, dict) else None
+    if enum_vals:
+        return enum_vals[0]
+
+    if type_name in ("string", "str"):
+        return "deep_validate"
+    if type_name in ("number", "float"):
+        return 1.0
+    if type_name in ("integer", "int"):
+        return 1
+    if type_name in ("boolean", "bool"):
+        return True
+    if type_name == "array":
+        items = spec.get("items") if isinstance(spec, dict) else None
+        if isinstance(items, (dict, str)):
+            return [_schema_default_value(items)]
+        return []
+    if type_name in ("object", "dict"):
+        props = spec.get("properties") if isinstance(spec, dict) else None
+        if isinstance(props, dict):
+            return {key: _schema_default_value(sub) for key, sub in props.items()}
+        return {}
+    return "deep_validate"
+
+
+def ai_agent_fixture(config: Dict[str, Any]) -> Dict[str, Any]:
+    """AIAgentNode deep fixture — schema-shaped ``{"response": ...}``, no LLM call.
+
+    A deep run must never hit a live LLM (cost, non-determinism, network) nor
+    silently swallow a failed model call. This builds the ``response`` output
+    port directly from the node's declared ``output_format`` / ``output_schema``
+    so downstream consumers see the same shape they would at runtime:
+
+    - ``"structured"`` + ``output_schema`` → a dict with every declared field
+      populated by a type-correct placeholder (enum → first value, nested
+      object/array shaped recursively). This is what makes
+      ``{{ nodes.<agent>.response.<field> }}`` bindings resolve in deep mode.
+    - ``"json"`` → an empty dict (no schema to shape it).
+    - ``"text"`` / anything else → a placeholder string.
+    """
+    output_format = config.get("output_format", "text")
+    output_schema = config.get("output_schema")
+    if output_format == "structured" and isinstance(output_schema, dict) and output_schema:
+        response: Any = {
+            key: _schema_default_value(spec) for key, spec in output_schema.items()
+        }
+    elif output_format == "json":
+        response = {}
+    else:  # "text" or unknown → raw string
+        response = "deep_validate: AIAgentNode response (virtual run, no live LLM call)"
+    return {"response": response}
+
+
 def apply_override(default: Dict[str, Any], override: Optional[Dict[str, Any]]) -> Dict[str, Any]:
     """Shallow-merge a caller override on top of a default fixture.