coreason-manifest 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

coreason_manifest/engine.py

@@ -80,29 +80,30 @@ class ManifestEngineAsync:
         # Clean up resources if necessary.
         pass
 
-    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.
+    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:
-            manifest_path: Path to the agent.yaml file.
-            source_dir: Path to the source code directory.
+            raw_data: The raw dictionary of the manifest.
 
         Returns:
-            AgentDefinition: The fully validated and verified agent definition.
+            AgentDefinition: The fully validated 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)
+        # 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...")
@@ -128,13 +129,42 @@ class ManifestEngineAsync:
             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 cast(AgentDefinition, agent_def)
+        return agent_def
 
 
 class ManifestEngine:
@@ -179,3 +209,14 @@ class ManifestEngine:
             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/loader.py

@@ -7,15 +7,23 @@ dictionaries, normalizing the data, and converting it into Pydantic models.
 
 from __future__ import annotations
 
+import inspect
 from pathlib import Path
-from typing import Any, Union
+from typing import Any, Callable, Dict, List, Union, get_type_hints
+
+try:
+    from typing import get_args, get_origin
+except ImportError:  # pragma: no cover
+    # For Python < 3.8, though project requires 3.12+
+    from typing_extensions import get_args, get_origin  # type: ignore
 
 import aiofiles
 import yaml
-from pydantic import ValidationError
+from coreason_identity import UserContext
+from pydantic import ValidationError, create_model
 
 from coreason_manifest.errors import ManifestSyntaxError
-from coreason_manifest.models import AgentDefinition
+from coreason_manifest.models import AgentDefinition, AgentInterface
 
 
 class ManifestLoader:
@@ -156,3 +164,108 @@ class ManifestLoader:
                 while version and version[0] in ("v", "V"):
                     version = version[1:]
                 data["metadata"]["version"] = version
+
+    @staticmethod
+    def inspect_function(func: Callable[..., Any]) -> AgentInterface:
+        """Generates an AgentInterface from a Python function.
+
+        Scans the function signature. If `user_context` (by name) or UserContext (by type)
+        is found, it is marked as injected and excluded from the public schema.
+
+        Args:
+            func: The function to inspect.
+
+        Returns:
+            AgentInterface: The generated interface definition.
+
+        Raises:
+            ManifestSyntaxError: If forbidden arguments are found.
+        """
+        sig = inspect.signature(func)
+        try:
+            type_hints = get_type_hints(func)
+        except Exception:
+            # Fallback if get_type_hints fails (e.g. forward refs issues)
+            type_hints = {}
+
+        field_definitions: Dict[str, Any] = {}
+        injected: List[str] = []
+
+        for param_name, param in sig.parameters.items():
+            if param_name in ("self", "cls"):
+                continue
+
+            # Determine type annotation
+            annotation = type_hints.get(param_name, param.annotation)
+            if annotation is inspect.Parameter.empty:
+                annotation = Any
+
+            # Check for forbidden arguments
+            if param_name in ("api_key", "token"):
+                raise ManifestSyntaxError(f"Function argument '{param_name}' is forbidden. Use UserContext for auth.")
+
+            # Check for injection
+            is_injected = False
+            if param_name == "user_context":
+                is_injected = True
+            else:
+                # Check direct type
+                if annotation is UserContext:
+                    is_injected = True
+                else:
+                    # Check for Optional[UserContext], Annotated[UserContext, ...], Union[UserContext, ...]
+                    origin = get_origin(annotation)
+                    args = get_args(annotation)
+                    if origin is not None:
+                        # Recursively check if UserContext is in args (handles Optional/Union)
+                        # or if this is Annotated (UserContext might be the first arg)
+                        # We do a shallow check on args.
+                        for arg in args:
+                            if arg is UserContext:
+                                is_injected = True
+                                break
+
+            if is_injected:
+                if "user_context" not in injected:
+                    injected.append("user_context")
+                continue
+
+            # Prepare for Pydantic model creation
+            default = param.default
+            if default is inspect.Parameter.empty:
+                default = ...
+
+            field_definitions[param_name] = (annotation, default)
+
+        # Create dynamic model to generate JSON Schema for inputs
+        # We assume strict mode or similar is handled by the consumer, here we just describe it.
+        try:
+            InputsModel = create_model("Inputs", **field_definitions)
+            inputs_schema = InputsModel.model_json_schema()
+        except Exception as e:
+            raise ManifestSyntaxError(f"Failed to generate schema from function signature: {e}") from e
+
+        # Handle return type for outputs
+        return_annotation = type_hints.get("return", sig.return_annotation)
+        outputs_schema = {}
+        if (
+            return_annotation is not inspect.Parameter.empty
+            and return_annotation is not None
+            and return_annotation is not type(None)
+        ):
+            try:
+                # If return annotation is a Pydantic model, use its schema
+                if hasattr(return_annotation, "model_json_schema"):
+                    outputs_schema = return_annotation.model_json_schema()
+                else:
+                    # Wrap in a model
+                    OutputsModel = create_model("Outputs", result=(return_annotation, ...))
+                    outputs_schema = OutputsModel.model_json_schema()
+            except Exception:
+                pass
+
+        return AgentInterface(
+            inputs=inputs_schema,
+            outputs=outputs_schema,
+            injected_params=injected,
+        )

coreason_manifest/models.py

@@ -20,6 +20,7 @@ from pydantic import (
     Field,
     PlainSerializer,
     field_validator,
+    model_validator,
 )
 from typing_extensions import Annotated
 
@@ -86,6 +87,7 @@ class AgentMetadata(BaseModel):
     name: str = Field(..., min_length=1, description="Name of the Agent.")
     author: str = Field(..., min_length=1, description="Author of the Agent.")
     created_at: datetime = Field(..., description="Creation timestamp (ISO 8601).")
+    requires_auth: bool = Field(default=False, description="Whether the agent requires user authentication.")
 
 
 class AgentInterface(BaseModel):
@@ -100,6 +102,7 @@ class AgentInterface(BaseModel):
 
     inputs: ImmutableDict = Field(..., description="Typed arguments the agent accepts (JSON Schema).")
     outputs: ImmutableDict = Field(..., description="Typed structure of the result.")
+    injected_params: List[str] = Field(default_factory=list, description="List of parameters injected by the system.")
 
 
 class Step(BaseModel):
@@ -218,3 +221,11 @@ class AgentDefinition(BaseModel):
         pattern=r"^[a-fA-F0-9]{64}$",
         description="SHA256 hash of the source code.",
     )
+
+    @model_validator(mode="after")
+    def validate_auth_requirements(self) -> AgentDefinition:
+        """Validate that agents requiring auth have user_context injected."""
+        if self.metadata.requires_auth:
+            if "user_context" not in self.interface.injected_params:
+                raise ValueError("Agent requires authentication but 'user_context' is not an injected parameter.")
+        return self

coreason_manifest/schemas/agent.schema.json

@@ -41,6 +41,14 @@
           "description": "Typed structure of the result.",
           "title": "Outputs",
           "type": "object"
+        },
+        "injected_params": {
+          "description": "List of parameters injected by the system.",
+          "items": {
+            "type": "string"
+          },
+          "title": "Injected Params",
+          "type": "array"
         }
       },
       "required": [
@@ -83,6 +91,12 @@
           "format": "date-time",
           "title": "Created At",
           "type": "string"
+        },
+        "requires_auth": {
+          "default": false,
+          "description": "Whether the agent requires user authentication.",
+          "title": "Requires Auth",
+          "type": "boolean"
         }
       },
       "required": [

coreason_manifest/server.py

@@ -0,0 +1,123 @@
+from contextlib import asynccontextmanager
+from importlib import resources
+from pathlib import Path
+from typing import AsyncIterator, List, Optional, Union
+
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+
+from coreason_manifest.engine import ManifestConfig, ManifestEngineAsync
+from coreason_manifest.errors import ManifestSyntaxError, PolicyViolationError
+
+
+# Response Model
+class ValidationResponse(BaseModel):
+    valid: bool
+    agent_id: Optional[str] = None
+    version: Optional[str] = None
+    policy_violations: List[str] = Field(default_factory=list)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+    # Locate policies
+    policy_path: Optional[Path] = None
+    tbom_path: Optional[Path] = None
+
+    # 1. Check local directory (Docker runtime with COPY or relative dev path)
+    # In Docker we will COPY to /app/policies/ or ./policies/ relative to WORKDIR
+    # We'll check common locations.
+    possible_dirs = [
+        Path("policies"),
+        Path("/app/policies"),
+        Path("src/coreason_manifest/policies"),  # Dev from root
+    ]
+
+    for d in possible_dirs:
+        if (d / "compliance.rego").exists():
+            policy_path = d / "compliance.rego"
+            if (d / "tbom.json").exists():
+                tbom_path = d / "tbom.json"
+            break
+
+    # 2. Fallback to package resources
+    resource_context = None
+    if not policy_path:
+        try:
+            # Check if it exists as a resource
+            ref = resources.files("coreason_manifest.policies").joinpath("compliance.rego")
+            if ref.is_file():
+                resource_context = resources.as_file(ref)
+                policy_path = resource_context.__enter__()
+                # Check for TBOM in same dir if possible, or ignore for fallback
+        except Exception:
+            pass
+
+    # If still not found, fail.
+    if not policy_path:
+        raise RuntimeError("Could not locate compliance.rego policy file.")
+
+    config = ManifestConfig(
+        policy_path=policy_path,
+        tbom_path=tbom_path,
+        opa_path="opa",  # Assumes OPA is in PATH (installed via Dockerfile)
+    )
+
+    engine = ManifestEngineAsync(config)
+
+    try:
+        async with engine:
+            app.state.engine = engine
+            yield
+    finally:
+        if resource_context:
+            resource_context.__exit__(None, None, None)
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.post("/validate", response_model=ValidationResponse)  # type: ignore[misc]
+async def validate_manifest(request: Request) -> Union[ValidationResponse, JSONResponse]:
+    engine: ManifestEngineAsync = app.state.engine
+
+    try:
+        raw_body = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON body") from None
+
+    try:
+        agent_def = await engine.validate_manifest_dict(raw_body)
+        return ValidationResponse(
+            valid=True,
+            agent_id=str(agent_def.metadata.id),
+            version=agent_def.metadata.version,
+            policy_violations=[],
+        )
+    except ManifestSyntaxError as e:
+        # Return 422 with the error
+        resp = ValidationResponse(valid=False, policy_violations=[f"Syntax Error: {str(e)}"])
+        return JSONResponse(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, content=resp.model_dump())
+    except PolicyViolationError as e:
+        resp = ValidationResponse(valid=False, policy_violations=e.violations)
+        return JSONResponse(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, content=resp.model_dump())
+
+
+@app.get("/health")  # type: ignore[misc]
+async def health_check() -> dict[str, str]:
+    engine: ManifestEngineAsync = app.state.engine
+    policy_version = "unknown"
+    try:
+        import hashlib
+
+        # policy_path is guaranteed to exist by lifespan check
+        policy_path = Path(engine.config.policy_path)
+        if policy_path.exists():
+            with open(policy_path, "rb") as f:
+                digest = hashlib.sha256(f.read()).hexdigest()[:8]
+            policy_version = digest
+    except Exception:
+        pass
+
+    return {"status": "active", "policy_version": policy_version}

{coreason_manifest-0.3.0.dist-info → coreason_manifest-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreason_manifest
-Version: 0.3.0
+Version: 0.5.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
          
@@ -68,12 +68,15 @@ 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.3.0,<5.0.0)
-Requires-Dist: httpx (>=0.27.0,<0.28.0)
+Requires-Dist: anyio (>=4.12.1,<5.0.0)
+Requires-Dist: coreason-identity (>=0.1.0,<0.2.0)
+Requires-Dist: fastapi (>=0.111.0,<0.112.0)
+Requires-Dist: httpx (>=0.28.1,<0.29.0)
 Requires-Dist: jsonschema (>=4.25.1,<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.30.1,<0.31.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
@@ -97,8 +100,10 @@ The definitive source of truth for CoReason-AI Asset definitions. "The Blueprint
 *   **Open Agent Specification (OAS) Validation:** Parses and validates agent definitions against a strict schema.
 *   **Compliance Enforcement:** Uses Open Policy Agent (OPA) / Rego to enforce complex business rules and allowlists.
 *   **Integrity Verification:** Calculates and verifies SHA256 hashes of the agent's source code to prevent tampering.
+*   **Automatic Schema Generation:** Inspects Python functions to generate Agent Interfaces, automatically handling `UserContext` injection.
 *   **Dependency Pinning:** Enforces strict version pinning for all library dependencies.
 *   **Trusted Bill of Materials (TBOM):** Validates libraries against an approved list.
+*   **Compliance Microservice:** Can be run as a standalone API server (Service C) for centralized validation.
 
 ## Installation
 
@@ -108,30 +113,30 @@ pip install coreason-manifest
 
 ## Usage
 
-Here is how to initialize the engine and validate an agent manifest:
+`coreason-manifest` supports two modes: **Library (CLI)** and **Server (Microservice)**.
+
+### 1. Library Usage
+
+Use the python library to validate local agent files and verify source integrity.
 
 ```python
-from coreason_manifest import ManifestEngine, ManifestConfig, PolicyViolationError, IntegrityCompromisedError
+from coreason_manifest import ManifestEngine, ManifestConfig
 
-# 1. Initialize configuration with policy path
-config = ManifestConfig(policy_path="./policies/gx_compliant.rego")
+# Initialize and Validate
+config = ManifestConfig(policy_path="./policies/compliance.rego")
 engine = ManifestEngine(config)
+agent_def = engine.load_and_validate("agent.yaml", "./src")
+```
 
-# 2. Load & Validate Agent Manifest
-try:
-    # This runs Schema Validation, Policy Enforcement, and Integrity Checks
-    agent_def = engine.load_and_validate(
-        manifest_path="./agents/payer_war_game/agent.yaml",
-        source_dir="./agents/payer_war_game/src"
-    )
-    print(f"Agent {agent_def.metadata.name} is compliant and ready to run.")
+### 2. Server Mode
 
-except PolicyViolationError as e:
-    print(f"Compliance Failure: {e.violations}")
+Run the package as a FastAPI server to provide a centralized compliance API.
 
-except IntegrityCompromisedError:
-    print("CRITICAL: Code has been tampered with after signing.")
+```bash
+uvicorn coreason_manifest.server:app --host 0.0.0.0 --port 8000
 ```
 
-For detailed requirements and architecture, please refer to the [Product Requirements](docs/product_requirements.md).
+For full details, see the [Usage Documentation](docs/usage.md).
+
+For detailed requirements and architecture, please refer to the [Product Requirements](docs/product_requirements.md) or [Requirements](docs/requirements.md).
 

{coreason_manifest-0.3.0.dist-info → coreason_manifest-0.5.0.dist-info}/RECORD

@@ -1,20 +1,21 @@
 coreason_manifest/__init__.py,sha256=R07xUHw9RWdWQPh7OWbpMT8kkzkEWfEI5hizu_5UNck,1528
-coreason_manifest/engine.py,sha256=zR_O2N-olwL1HSjAq03Um3qr-jbzmaIhOA19tpY0tFs,6753
+coreason_manifest/engine.py,sha256=ENAkRuGFd1uY_5u4EYEsTZUMrqw5HgijKtkF9lk-E-c,8199
 coreason_manifest/errors.py,sha256=CKFWSucncoPLYUJcsuXtLIfneyr2d89oHRTiWPT4psU,1437
 coreason_manifest/integrity.py,sha256=CMBaa2A8DpC9hDSO-aj-YOzss6if1CajaeLEmTC703c,5344
-coreason_manifest/loader.py,sha256=cc1iV-yKfH3gyPaB-P_7AaTaPYkgj1NoDsJz4PReTgo,5479
+coreason_manifest/loader.py,sha256=WET8HAnSw4dgon_zdiZaaU1dIUrsIQPYZzxlp0crTYo,10027
 coreason_manifest/main.py,sha256=YQO98w2wxkfNs-DpSLmiDTs9DtUeGsC48GEfbElXVPk,357
-coreason_manifest/models.py,sha256=pJIuEtCiiXcxxi2zRwken4ph2GFa66YHnOqHyySR5sU,6828
+coreason_manifest/models.py,sha256=EuaE1Wl5T8f_eI9vF1VFp5hd0y9C7E52zAjB52EulKw,7497
 coreason_manifest/policies/compliance.rego,sha256=-drMuno6YkGOXKjvdLWawCZWK8iUxY7OcXpoXa_9Oyo,3035
 coreason_manifest/policies/tbom.json,sha256=rSn4V44_IdFqCC86J3Jc31qQKTV4J5BdmyO0CI4iOu0,167
 coreason_manifest/policy.py,sha256=vvEivq5HSjv-bMSrZ5VMM3eTomYFp39SBtuFajG9RU4,5009
 coreason_manifest/schemas/__init__.py,sha256=9TMs6jWKCIewAKkj-u0tq9c6N_-0CU6b5s9q6MTS6v4,17
-coreason_manifest/schemas/agent.schema.json,sha256=wdNYmpyCUEKR1UgMmRV4ZSQOm7xvnmSg5lvhQ3JKvSg,6368
+coreason_manifest/schemas/agent.schema.json,sha256=VigUX3ltX7YaW9P7n0DNYGNOf8C6VCuXNy71u3LB9i4,6812
+coreason_manifest/server.py,sha256=kHrReqoEx4sL5k5GQN7yNwLgvfnOl1kZf-dQehseuO4,4251
 coreason_manifest/utils/__init__.py,sha256=Q9gXiBtX3mD9GTu4z0JDHSHkbXC-MRHagrOaOmRH_1Q,435
 coreason_manifest/utils/logger.py,sha256=A7E6Hd_Jk1XDUajNEJQl-WtUv9M2LT76b4_TsbxnILw,1227
 coreason_manifest/validator.py,sha256=v33EzKroRwLEjZeuRRpTB7cqB38op3DV2EZpZhJ80a0,2240
-coreason_manifest-0.3.0.dist-info/METADATA,sha256=7a-XR2oNa4OqWlD9RqkuOc7B709pHJfu7BsKoHJxRis,7176
-coreason_manifest-0.3.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-coreason_manifest-0.3.0.dist-info/licenses/LICENSE,sha256=3tYb7ZQe7sVXcbNmX22fDESFjOSIlCZodUGpZMkuSlk,3063
-coreason_manifest-0.3.0.dist-info/licenses/NOTICE,sha256=tqzUyP9VTCGxoHLgBI0AC1i0G7m_PSyESFL8Jwuw0dA,610
-coreason_manifest-0.3.0.dist-info/RECORD,,
+coreason_manifest-0.5.0.dist-info/METADATA,sha256=GZU4pj0fFgv6x80fJDa71xfQTYCHH1BPnZnSdjv3kBo,7421
+coreason_manifest-0.5.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+coreason_manifest-0.5.0.dist-info/licenses/LICENSE,sha256=3tYb7ZQe7sVXcbNmX22fDESFjOSIlCZodUGpZMkuSlk,3063
+coreason_manifest-0.5.0.dist-info/licenses/NOTICE,sha256=tqzUyP9VTCGxoHLgBI0AC1i0G7m_PSyESFL8Jwuw0dA,610
+coreason_manifest-0.5.0.dist-info/RECORD,,