coreason-manifest 0.5.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

coreason_manifest/__init__.py

@@ -1,59 +1,17 @@
-# Prosperity-3.0
-"""Coreason Manifest Package.
-
-This package provides the core functionality for the Coreason Manifest system,
-including loading, validation, policy enforcement, and integrity checking of
-agent definitions.
-
-The `coreason-manifest` package serves as the definitive source of truth for
-Asset definitions in the CoReason-AI ecosystem.
-
-Usage:
-    from coreason_manifest import ManifestEngine, ManifestConfig
-
-    config = ManifestConfig(policy_path="./policies/gx_compliant.rego")
-    engine = ManifestEngine(config)
-    agent_def = engine.load_and_validate("agent.yaml", "./src")
-"""
-
-from .engine import ManifestConfig, ManifestEngine, ManifestEngineAsync
-from .errors import (
-    IntegrityCompromisedError,
-    ManifestError,
-    ManifestSyntaxError,
-    PolicyViolationError,
-)
-from .integrity import IntegrityChecker
-from .loader import ManifestLoader
-from .models import (
-    AgentDefinition,
-    AgentDependencies,
-    AgentInterface,
-    AgentMetadata,
-    AgentTopology,
-    ModelConfig,
-    Step,
-)
-from .policy import PolicyEnforcer
-from .validator import SchemaValidator
+from .definitions.agent import AgentDefinition
+from .definitions.audit import AuditLog
+from .definitions.simulation import SimulationScenario, SimulationTrace, SimulationTurn
+from .definitions.topology import Edge, Node, Topology
+from .recipes import RecipeManifest
 
 __all__ = [
     "AgentDefinition",
-    "AgentDependencies",
-    "AgentInterface",
-    "AgentMetadata",
-    "AgentTopology",
-    "IntegrityChecker",
-    "IntegrityCompromisedError",
-    "ManifestConfig",
-    "ManifestEngine",
-    "ManifestEngineAsync",
-    "ManifestError",
-    "ManifestLoader",
-    "ManifestSyntaxError",
-    "ModelConfig",
-    "PolicyEnforcer",
-    "PolicyViolationError",
-    "SchemaValidator",
-    "Step",
+    "Topology",
+    "Node",
+    "Edge",
+    "SimulationScenario",
+    "SimulationTrace",
+    "SimulationTurn",
+    "AuditLog",
+    "RecipeManifest",
 ]

coreason_manifest/definitions/audit.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class AuditLog(BaseModel):
+    """Audit log entry."""
+
+    pass

coreason_manifest/definitions/simulation.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+
+
+class SimulationScenario(BaseModel):
+    """Definition of a simulation scenario."""
+
+    pass
+
+
+class SimulationTrace(BaseModel):
+    """Trace of a simulation execution."""
+
+    pass
+
+
+class SimulationTurn(BaseModel):
+    """A single turn in a simulation."""
+
+    pass

coreason_manifest/definitions/topology.py

@@ -0,0 +1,140 @@
+# Copyright (c) 2025 CoReason, Inc.
+#
+# This software is proprietary and dual-licensed.
+# Licensed under the Prosperity Public License 3.0 (the "License").
+# A copy of the license is available at https://prosperitylicense.com/versions/3.0.0
+# For details, see the LICENSE file.
+# Commercial use beyond a 30-day trial requires a separate license.
+#
+# Source Code: https://github.com/CoReason-AI/coreason_maco
+
+from typing import Annotated, List, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class CouncilConfig(BaseModel):
+    """Configuration for 'Architectural Triangulation'.
+
+    Attributes:
+        strategy: The strategy for the council (e.g., 'consensus').
+        voters: List of agents or models that vote.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    strategy: str = Field(default="consensus", description="The strategy for the council, e.g., 'consensus'.")
+    voters: List[str] = Field(..., description="List of agents or models that vote.")
+
+
+class VisualMetadata(BaseModel):
+    """Data explicitly for the UI.
+
+    Attributes:
+        label: The label to display for the node.
+        x_y_coordinates: The X and Y coordinates for the node on the canvas.
+        icon: The icon to represent the node.
+        animation_style: The animation style for the node.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    label: Optional[str] = Field(None, description="The label to display for the node.")
+    x_y_coordinates: Optional[List[float]] = Field(
+        None, description="The X and Y coordinates for the node on the canvas."
+    )
+    icon: Optional[str] = Field(None, description="The icon to represent the node.")
+    animation_style: Optional[str] = Field(None, description="The animation style for the node.")
+
+
+class BaseNode(BaseModel):
+    """Base model for all node types.
+
+    Attributes:
+        id: Unique identifier for the node.
+        council_config: Optional configuration for architectural triangulation.
+        visual: Visual metadata for the UI.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    id: str = Field(..., description="Unique identifier for the node.")
+    council_config: Optional[CouncilConfig] = Field(
+        None, description="Optional configuration for architectural triangulation."
+    )
+    visual: Optional[VisualMetadata] = Field(None, description="Visual metadata for the UI.")
+
+
+class AgentNode(BaseNode):
+    """A node that calls a specific atomic agent.
+
+    Attributes:
+        type: The type of the node (must be 'agent').
+        agent_name: The name of the atomic agent to call.
+    """
+
+    type: Literal["agent"] = Field("agent", description="Discriminator for AgentNode.")
+    agent_name: str = Field(..., description="The name of the atomic agent to call.")
+
+
+class HumanNode(BaseNode):
+    """A node that pauses execution for user input/approval.
+
+    Attributes:
+        type: The type of the node (must be 'human').
+        timeout_seconds: Optional timeout in seconds for the user interaction.
+    """
+
+    type: Literal["human"] = Field("human", description="Discriminator for HumanNode.")
+    timeout_seconds: Optional[int] = Field(None, description="Optional timeout in seconds for the user interaction.")
+
+
+class LogicNode(BaseNode):
+    """A node that executes pure Python logic.
+
+    Attributes:
+        type: The type of the node (must be 'logic').
+        code: The Python logic code to execute.
+    """
+
+    type: Literal["logic"] = Field("logic", description="Discriminator for LogicNode.")
+    code: str = Field(..., description="The Python logic code to execute.")
+
+
+# Discriminated Union for polymorphism
+Node = Annotated[
+    Union[AgentNode, HumanNode, LogicNode], Field(discriminator="type", description="Polymorphic node definition.")
+]
+
+
+class Edge(BaseModel):
+    """Represents a connection between two nodes.
+
+    Attributes:
+        source_node_id: The ID of the source node.
+        target_node_id: The ID of the target node.
+        condition: Optional Python expression for conditional branching.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    source_node_id: str = Field(..., description="The ID of the source node.")
+    target_node_id: str = Field(..., description="The ID of the target node.")
+    condition: Optional[str] = Field(None, description="Optional Python expression for conditional branching.")
+
+
+class GraphTopology(BaseModel):
+    """The topology definition of the recipe.
+
+    Attributes:
+        nodes: List of nodes in the graph.
+        edges: List of edges connecting the nodes.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    nodes: List[Node] = Field(..., description="List of nodes in the graph.")
+    edges: List[Edge] = Field(..., description="List of edges connecting the nodes.")
+
+
+Topology = GraphTopology

coreason_manifest/recipes.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2025 CoReason, Inc.
+#
+# This software is proprietary and dual-licensed.
+# Licensed under the Prosperity Public License 3.0 (the "License").
+# A copy of the license is available at https://prosperitylicense.com/versions/3.0.0
+# For details, see the LICENSE file.
+# Commercial use beyond a 30-day trial requires a separate license.
+#
+# Source Code: https://github.com/CoReason-AI/coreason_maco
+
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .definitions.agent import VersionStr
+from .definitions.topology import GraphTopology
+
+
+class RecipeManifest(BaseModel):
+    """The executable specification for the MACO engine.
+
+    Attributes:
+        id: Unique identifier for the recipe.
+        version: Version of the recipe.
+        name: Human-readable name of the recipe.
+        description: Detailed description of the recipe.
+        inputs: Schema defining global variables this recipe accepts.
+        graph: The topology definition of the workflow.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    id: str = Field(..., description="Unique identifier for the recipe.")
+    version: VersionStr = Field(..., description="Version of the recipe.")
+    name: str = Field(..., description="Human-readable name of the recipe.")
+    description: Optional[str] = Field(None, description="Detailed description of the recipe.")
+    inputs: Dict[str, Any] = Field(..., description="Schema defining global variables this recipe accepts.")
+    graph: GraphTopology = Field(..., description="The topology definition of the workflow.")

{coreason_manifest-0.5.1.dist-info → coreason_manifest-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreason_manifest
-Version: 0.5.1
+Version: 0.7.0
 Summary: This package is the definitive source of truth. If it isn't in the manifest, it doesn't exist. If it violates the manifest, it doesn't run.
 License: # The Prosperity Public License 3.0.0
          
@@ -67,16 +67,10 @@ Requires-Python: >=3.12
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
-Requires-Dist: aiofiles (>=23.2.1,<24.0.0)
-Requires-Dist: anyio (>=4.12.1,<5.0.0)
 Requires-Dist: coreason-identity (>=0.4.1,<0.5.0)
-Requires-Dist: fastapi (>=0.128.0,<0.129.0)
-Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: jsonschema (>=4.26.0,<5.0.0)
 Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: pydantic (>=2.12.5,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
-Requires-Dist: uvicorn (>=0.40.0,<0.41.0)
 Project-URL: Documentation, https://github.com/CoReason-AI/coreason_manifest
 Project-URL: Homepage, https://github.com/CoReason-AI/coreason_manifest
 Project-URL: Repository, https://github.com/CoReason-AI/coreason_manifest

coreason_manifest-0.7.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+coreason_manifest/__init__.py,sha256=SNFD_w_XEalq8Mo6AEQNYsI-KEUkC9hf5r7d2jv-21k,453
+coreason_manifest/definitions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+coreason_manifest/definitions/agent.py,sha256=EuaE1Wl5T8f_eI9vF1VFp5hd0y9C7E52zAjB52EulKw,7497
+coreason_manifest/definitions/audit.py,sha256=_wWZN7sBlxVESrIPXFILit-6QWH6BCUQ1UGCAkxBlgI,97
+coreason_manifest/definitions/simulation.py,sha256=grC1_UeJc7l-IpgBuQhIuyKn22ZtgsoTk3FRRXE-NOo,302
+coreason_manifest/definitions/topology.py,sha256=a7pdCyvtVCFEewKehH58is55_2PCJC1C7yldCV2tdxM,4825
+coreason_manifest/recipes.py,sha256=ti17QdH6RhZbeve8jhROJgEkD-3GYOFoTk5pe3Ok_0I,1598
+coreason_manifest/schemas/__init__.py,sha256=9TMs6jWKCIewAKkj-u0tq9c6N_-0CU6b5s9q6MTS6v4,17
+coreason_manifest/schemas/agent.schema.json,sha256=VigUX3ltX7YaW9P7n0DNYGNOf8C6VCuXNy71u3LB9i4,6812
+coreason_manifest/utils/__init__.py,sha256=Q9gXiBtX3mD9GTu4z0JDHSHkbXC-MRHagrOaOmRH_1Q,435
+coreason_manifest/utils/logger.py,sha256=A7E6Hd_Jk1XDUajNEJQl-WtUv9M2LT76b4_TsbxnILw,1227
+coreason_manifest-0.7.0.dist-info/METADATA,sha256=J4MUZyT1RTEnZRoOPgVK_sISJ8CeU24kdkdL47E21Oo,7169
+coreason_manifest-0.7.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+coreason_manifest-0.7.0.dist-info/licenses/LICENSE,sha256=3tYb7ZQe7sVXcbNmX22fDESFjOSIlCZodUGpZMkuSlk,3063
+coreason_manifest-0.7.0.dist-info/licenses/NOTICE,sha256=tqzUyP9VTCGxoHLgBI0AC1i0G7m_PSyESFL8Jwuw0dA,610
+coreason_manifest-0.7.0.dist-info/RECORD,,

coreason_manifest/engine.py

@@ -1,222 +0,0 @@
-# Prosperity-3.0
-"""Engine for the Coreason Manifest system.
-
-This module provides the main entry point for verifying and loading Agent Manifests.
-It coordinates schema validation, policy enforcement, and integrity checking.
-"""
-
-from __future__ import annotations
-
-import time
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, List, Optional, Union, cast
-
-import anyio
-import anyio.to_thread
-
-from coreason_manifest.integrity import IntegrityChecker
-from coreason_manifest.loader import ManifestLoader
-from coreason_manifest.models import AgentDefinition
-from coreason_manifest.policy import PolicyEnforcer
-from coreason_manifest.utils.logger import logger
-from coreason_manifest.validator import SchemaValidator
-
-
-@dataclass
-class ManifestConfig:
-    """Configuration for the ManifestEngine.
-
-    Attributes:
-        policy_path: Path to the Rego policy file.
-        opa_path: Path to the OPA executable. Defaults to "opa".
-        tbom_path: Optional path to the Trusted Bill of Materials.
-        extra_data_paths: Additional data paths to load into OPA.
-    """
-
-    policy_path: Union[str, Path]
-    opa_path: str = "opa"
-    tbom_path: Optional[Union[str, Path]] = None
-    extra_data_paths: List[Union[str, Path]] = field(default_factory=list)
-
-
-class ManifestEngineAsync:
-    """The async core for verifying and loading Agent Manifests.
-
-    This class coordinates the validation process, including:
-    1.  Loading raw YAML.
-    2.  Validating against JSON Schema.
-    3.  Converting to AgentDefinition Pydantic model (Normalization).
-    4.  Enforcing Policy (Rego).
-    5.  Verifying Integrity (Hash check).
-    """
-
-    def __init__(self, config: ManifestConfig) -> None:
-        """Initialize the ManifestEngineAsync.
-
-        Args:
-            config: Configuration including policy path and OPA path.
-        """
-        self.config = config
-        self.schema_validator = SchemaValidator()
-
-        # Collect data paths
-        data_paths = list(config.extra_data_paths)
-        if config.tbom_path:
-            data_paths.append(config.tbom_path)
-
-        self.policy_enforcer = PolicyEnforcer(
-            policy_path=config.policy_path,
-            opa_path=config.opa_path,
-            data_paths=data_paths,
-        )
-
-    async def __aenter__(self) -> ManifestEngineAsync:
-        """Async context manager entry."""
-        return self
-
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Async context manager exit."""
-        # Clean up resources if necessary.
-        pass
-
-    async def validate_manifest_dict(self, raw_data: dict[str, Any]) -> AgentDefinition:
-        """Validates an Agent Manifest dictionary in memory.
-
-        Performs:
-        1. Normalization (stripping version prefixes)
-        2. Schema Validation
-        3. Model Conversion
-        4. Policy Enforcement
-
-        Does NOT perform Integrity Check (hashing).
-
-        Args:
-            raw_data: The raw dictionary of the manifest.
-
-        Returns:
-            AgentDefinition: The fully validated agent definition.
-
-        Raises:
-            ManifestSyntaxError: If structure or schema is invalid.
-            PolicyViolationError: If business rules are violated.
-        """
-        # 1. Normalization (ensure version string is clean before schema/model validation)
-        # We access the static method on ManifestLoader.
-        ManifestLoader._normalize_data(raw_data)
-
-        # 2. Schema Validation
-        logger.debug("Running Schema Validation...")
-        self.schema_validator.validate(raw_data)
-
-        # 3. Model Conversion (Normalization) (CPU bound)
-        logger.debug("Converting to AgentDefinition...")
-        agent_def = await anyio.to_thread.run_sync(ManifestLoader.load_from_dict, raw_data)
-        logger.info(f"Validating Agent {agent_def.metadata.id} v{agent_def.metadata.version}")
-
-        # 4. Policy Enforcement (Subprocess / Blocking)
-        logger.debug("Enforcing Policies...")
-        # We assume policy is checked against the Normalized data (model dumped back to dict)
-        normalized_data = agent_def.model_dump(mode="json")
-        start_time = time.perf_counter()
-        try:
-            # PolicyEnforcer.evaluate is synchronous and runs subprocess.run, so we wrap it.
-            await anyio.to_thread.run_sync(self.policy_enforcer.evaluate, normalized_data)
-            duration_ms = (time.perf_counter() - start_time) * 1000
-            logger.info(f"Policy Check: Pass - {duration_ms:.2f}ms")
-        except Exception:
-            duration_ms = (time.perf_counter() - start_time) * 1000
-            logger.info(f"Policy Check: Fail - {duration_ms:.2f}ms")
-            raise
-
-        return cast(AgentDefinition, agent_def)
-
-    async def load_and_validate(self, manifest_path: Union[str, Path], source_dir: Union[str, Path]) -> AgentDefinition:
-        """Loads, validates, and verifies an Agent Manifest asynchronously.
-
-        Args:
-            manifest_path: Path to the agent.yaml file.
-            source_dir: Path to the source code directory.
-
-        Returns:
-            AgentDefinition: The fully validated and verified agent definition.
-
-        Raises:
-            ManifestSyntaxError: If structure or schema is invalid.
-            PolicyViolationError: If business rules are violated.
-            IntegrityCompromisedError: If source code hash does not match.
-            FileNotFoundError: If files are missing.
-        """
-        manifest_path = Path(manifest_path)
-        source_dir = Path(source_dir)
-
-        logger.info(f"Validating Agent Manifest: {manifest_path}")
-
-        # 1. Load Raw YAML (I/O)
-        raw_data = await ManifestLoader.load_raw_from_file_async(manifest_path)
-
-        # 2. Validate Manifest Dict (Schema, Model, Policy)
-        agent_def = await self.validate_manifest_dict(raw_data)
-
-        # 5. Integrity Check (Heavy I/O and CPU)
-        logger.debug("Verifying Integrity...")
-        # IntegrityChecker.verify is synchronous and does heavy IO, so we wrap it.
-        await anyio.to_thread.run_sync(IntegrityChecker.verify, agent_def, source_dir, manifest_path)
-
-        logger.info("Agent validation successful.")
-        return agent_def
-
-
-class ManifestEngine:
-    """The Sync Facade for ManifestEngineAsync.
-
-    Allows synchronous usage of the async core via anyio.run.
-    """
-
-    def __init__(self, config: ManifestConfig) -> None:
-        """Initialize the ManifestEngine facade.
-
-        Args:
-            config: Configuration including policy path and OPA path.
-        """
-        self._async = ManifestEngineAsync(config)
-
-    def __getattr__(self, name: str) -> Any:
-        """Delegate attribute access to the async engine instance.
-
-        This ensures backward compatibility for accessing attributes like
-        'config', 'schema_validator', and 'policy_enforcer'.
-        """
-        return getattr(self._async, name)
-
-    def __enter__(self) -> ManifestEngine:
-        """Context manager entry."""
-        anyio.run(self._async.__aenter__)
-        return self
-
-    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Context manager exit."""
-        anyio.run(self._async.__aexit__, exc_type, exc_val, exc_tb)
-
-    def load_and_validate(self, manifest_path: Union[str, Path], source_dir: Union[str, Path]) -> AgentDefinition:
-        """Loads, validates, and verifies an Agent Manifest synchronously.
-
-        Args:
-            manifest_path: Path to the agent.yaml file.
-            source_dir: Path to the source code directory.
-
-        Returns:
-            AgentDefinition: The fully validated and verified agent definition.
-        """
-        return cast(AgentDefinition, anyio.run(self._async.load_and_validate, manifest_path, source_dir))
-
-    def validate_manifest_dict(self, raw_data: dict[str, Any]) -> AgentDefinition:
-        """Validates an Agent Manifest dictionary synchronously.
-
-        Args:
-            raw_data: The raw dictionary of the manifest.
-
-        Returns:
-            AgentDefinition: The fully validated agent definition.
-        """
-        return cast(AgentDefinition, anyio.run(self._async.validate_manifest_dict, raw_data))

coreason_manifest/errors.py

@@ -1,53 +0,0 @@
-# Prosperity-3.0
-"""Exceptions for the Coreason Manifest system.
-
-This module defines the hierarchy of exceptions raised by the package.
-"""
-
-from __future__ import annotations
-
-
-class ManifestError(Exception):
-    """Base exception for coreason_manifest errors."""
-
-    pass
-
-
-class ManifestSyntaxError(ManifestError):
-    """Raised when the manifest YAML is invalid or missing required fields.
-
-    This includes YAML parsing errors and JSON Schema validation failures.
-    """
-
-    pass
-
-
-class PolicyViolationError(ManifestError):
-    """Raised when the agent violates a compliance policy.
-
-    This error indicates that the manifest is structurally valid but fails
-    business rules or compliance checks (e.g., banned libraries).
-
-    Attributes:
-        violations: A list of specific policy violation messages.
-    """
-
-    def __init__(self, message: str, violations: list[str] | None = None) -> None:
-        """Initialize PolicyViolationError.
-
-        Args:
-            message: The error message.
-            violations: Optional list of detailed violation strings.
-        """
-        super().__init__(message)
-        self.violations = violations or []
-
-
-class IntegrityCompromisedError(ManifestError):
-    """Raised when the source code hash does not match the manifest.
-
-    This indicates that the source code may have been tampered with or changed
-    without updating the manifest's integrity hash.
-    """
-
-    pass