coreason-manifest 0.9.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

{coreason_manifest-0.9.0.dist-info → coreason_manifest-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreason_manifest
-Version: 0.9.0
+Version: 0.12.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,6 +68,7 @@ Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Dist: coreason-identity (>=0.4.1,<0.5.0)
+Requires-Dist: jsonschema (>=4.19.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)
@@ -87,17 +88,25 @@ The definitive source of truth for CoReason-AI Asset definitions. "The Blueprint
 
 ## Overview
 
-`coreason-manifest` acts as the validator for the "Agent Development Lifecycle" (ADLC). It ensures that every Agent produced meets strict GxP and security standards. If it isn't in the manifest, it doesn't exist. If it violates the manifest, it doesn't run.
+`coreason-manifest` serves as the **Shared Kernel** for the Coreason ecosystem. It contains the canonical Pydantic definitions, schemas, and data structures for Agents and Workflows (Recipes).
+
+It provides the **"Blueprint"** that all other services (Builder, Engine, Simulator) rely on. It focuses on strict typing, schema validation, and serialization, ensuring that if it isn't in the manifest, it doesn't exist.
+
+### Standards Clarification
+*Note: The "Coreason Agent Manifest" (CAM) is a proprietary, strict governance schema designed for the CoReason Platform. It is distinct from the Oracle/Linux Foundation "Open Agent Specification," though we aim for future interoperability via adapters.*
 
 ## Features
 
-*   **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.
+*   **Coreason Agent Manifest (CAM):** Strict Pydantic models for Agent definitions (`AgentDefinition`) and Recipes (`Recipe`).
+*   **Strict Typing:** Enforces type safety for critical interfaces.
+*   **Governance & Policy:** Enforce organizational rules (domains, risk levels) on agents via `GovernanceConfig`.
+*   **Ergonomic Factory Methods:** Simplified construction of manifests.
+*   **Flexible Tooling:** Support for external tool definitions (`ToolDefinition`) and risk levels (`ToolRiskLevel`).
+*   **Topology Visualization:** Workflows are defined as graph topologies (`Workflow`).
+
+## Serialization & Base Model
+
+Core definitions (e.g., `Manifest`, `Workflow`, `AgentDefinition`) inherit from Pydantic's `BaseModel`. Shared configuration models like `GovernanceConfig` inherit from `CoReasonBaseModel` for enhanced serialization capabilities.
 
 ## Installation
 
@@ -107,30 +116,60 @@ pip install coreason-manifest
 
 ## Usage
 
-`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.
+This library is used to define and validate Agent configurations programmatically.
 
 ```python
-from coreason_manifest import ManifestEngine, ManifestConfig
-
-# Initialize and Validate
-config = ManifestConfig(policy_path="./policies/compliance.rego")
-engine = ManifestEngine(config)
-agent_def = engine.load_and_validate("agent.yaml", "./src")
-```
-
-### 2. Server Mode
-
-Run the package as a FastAPI server to provide a centralized compliance API.
-
-```bash
-uvicorn coreason_manifest.server:app --host 0.0.0.0 --port 8000
+from coreason_manifest import (
+    Recipe,
+    ManifestMetadata,
+    AgentStep,
+    Workflow,
+    InterfaceDefinition,
+    StateDefinition,
+    PolicyDefinition
+)
+
+# 1. Define Metadata
+metadata = ManifestMetadata(
+    name="Research Agent",
+    version="1.0.0"
+)
+
+# 2. Define Workflow
+workflow = Workflow(
+    start="step1",
+    steps={
+        "step1": AgentStep(
+            id="step1",
+            agent="gpt-4-researcher",
+            next="step2"
+        ),
+        # ... define other steps
+    }
+)
+
+# 3. Instantiate Manifest
+manifest = Recipe(
+    apiVersion="coreason.ai/v2",
+    kind="Recipe",
+    metadata=metadata,
+    interface=InterfaceDefinition(
+        inputs={"topic": {"type": "string"}},
+        outputs={"summary": {"type": "string"}}
+    ),
+    state=StateDefinition(),
+    policy=PolicyDefinition(max_retries=3),
+    workflow=workflow
+)
+
+print(f"Manifest '{manifest.metadata.name}' created successfully.")
 ```
 
 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).
+## Documentation
+
+*   [Usage Guide](docs/usage.md): How to load and create manifests.
+*   [Governance & Policy Enforcement](docs/governance_policy_enforcement.md): Validating agents against organizational rules.
+*   [Coreason Agent Manifest (CAM)](docs/cap/specification.md): The Canonical YAML Authoring Format.
 

coreason_manifest-0.12.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+coreason_manifest/__init__.py,sha256=W74fAYQGapYpNq117NHIUeQvFddn22lJ4IxtMiVBtuE,1189
+coreason_manifest/common.py,sha256=ebQPiWiYSKFVAS6eXUyOIgJbsO8QDXVlFQKtSCQLRzg,2136
+coreason_manifest/governance.py,sha256=cR0q3TUbwTx2-ROGtVh9tP6o9XUiD2ekqoNsgCPDR2o,3299
+coreason_manifest/schemas/__init__.py,sha256=g1cCu1DprGcnGAiuvYWz5VeKKXIHYYwlrsqdkg9fRZY,412
+coreason_manifest/schemas/coreason-v2.schema.json,sha256=R2UqXEY1NSpNNtGpyJnjJ0jhnT4U6-2FKn-WPi4tnD0,11312
+coreason_manifest/utils/__init__.py,sha256=Kdz519fMq6c7Px3MP5oD_9jfqqFbCiaHPBQTc0LhyII,848
+coreason_manifest/utils/logger.py,sha256=dwvFVR2CuOjKsE0_59JsGqoIh8GpAwO6ATJDFt2SOlg,1640
+coreason_manifest/v2/__init__.py,sha256=1bWTcGLOXjSDv2TgYXoH5wsla0T2W2ulhUHsK5AzIgM,23
+coreason_manifest/v2/governance.py,sha256=nN2eu2YeASuDQglb35IOYm525LXWovMzAt9mba8loTY,5929
+coreason_manifest/v2/io.py,sha256=6B5wzyW-TbnKcUgOOBaurSdZg0kQPtPx35hlcsbe1Us,4311
+coreason_manifest/v2/resolver.py,sha256=lLPbNZcQjQ_GI71a7Rf-XiMM0CDgTy96nTLxm94gJLg,2313
+coreason_manifest/v2/spec/__init__.py,sha256=i8Agxsn9vs6wGCaxaHVNupRpPCeAIGTtiA9FKyoJsaU,40
+coreason_manifest/v2/spec/contracts.py,sha256=bDlYHDWlpSsIzDU8_fwXS2d0NjEHAPkIK3VpJbvcL7k,1354
+coreason_manifest/v2/spec/definitions.py,sha256=TV2JHBBq90jN18xg5sG9Y_swd1blcXyomLb1H6DkpW4,8603
+coreason_manifest/v2/validator.py,sha256=iTkpb_V38KbJ89h-Zne_1xep-XL44PS1PobZRnwV5K8,1504
+coreason_manifest-0.12.0.dist-info/METADATA,sha256=R9MkpePi9F8sGa14-aNahaerSNOvZcFaAeiGVKcDZHg,8278
+coreason_manifest-0.12.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+coreason_manifest-0.12.0.dist-info/licenses/LICENSE,sha256=3tYb7ZQe7sVXcbNmX22fDESFjOSIlCZodUGpZMkuSlk,3063
+coreason_manifest-0.12.0.dist-info/licenses/NOTICE,sha256=tqzUyP9VTCGxoHLgBI0AC1i0G7m_PSyESFL8Jwuw0dA,610
+coreason_manifest-0.12.0.dist-info/RECORD,,

{coreason_manifest-0.9.0.dist-info → coreason_manifest-0.12.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.3.0
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any

coreason_manifest/definitions/__init__.py

@@ -1,49 +0,0 @@
-from .agent import AgentDefinition, AgentRuntimeConfig
-from .events import (
-    ArtifactGenerated,
-    ArtifactGeneratedPayload,
-    CouncilVote,
-    CouncilVotePayload,
-    EdgeTraversed,
-    EdgeTraversedPayload,
-    GraphEvent,
-    NodeCompleted,
-    NodeCompletedPayload,
-    NodeInit,
-    # Export Aliases too
-    NodeInitPayload,
-    NodeRestored,
-    NodeSkipped,
-    NodeSkippedPayload,
-    NodeStarted,
-    NodeStartedPayload,
-    NodeStream,
-    NodeStreamPayload,
-    WorkflowError,
-    WorkflowErrorPayload,
-)
-
-__all__ = [
-    "AgentRuntimeConfig",
-    "AgentDefinition",
-    "GraphEvent",
-    "NodeInit",
-    "NodeStarted",
-    "NodeCompleted",
-    "NodeRestored",
-    "NodeSkipped",
-    "NodeStream",
-    "ArtifactGenerated",
-    "EdgeTraversed",
-    "CouncilVote",
-    "WorkflowError",
-    "NodeInitPayload",
-    "NodeStartedPayload",
-    "NodeCompletedPayload",
-    "NodeSkippedPayload",
-    "NodeStreamPayload",
-    "EdgeTraversedPayload",
-    "ArtifactGeneratedPayload",
-    "CouncilVotePayload",
-    "WorkflowErrorPayload",
-]

coreason_manifest/definitions/agent.py

@@ -1,292 +0,0 @@
-# Prosperity-3.0
-"""Pydantic models for the Coreason Manifest system.
-
-These models define the structure and validation rules for the Agent Manifest
-(OAS). They represent the source of truth for Agent definitions.
-"""
-
-from __future__ import annotations
-
-from datetime import datetime
-from enum import Enum
-from types import MappingProxyType
-from typing import Any, Dict, List, Mapping, Optional, Tuple
-from uuid import UUID
-
-from pydantic import (
-    AfterValidator,
-    AnyUrl,
-    BaseModel,
-    ConfigDict,
-    Field,
-    PlainSerializer,
-    field_validator,
-    model_validator,
-)
-from typing_extensions import Annotated
-
-from coreason_manifest.definitions.topology import Edge, Node
-
-# SemVer Regex pattern (simplified for standard SemVer)
-# Modified to accept optional 'v' or 'V' prefix (multiple allowed) for input normalization
-SEMVER_REGEX = (
-    r"^[vV]*(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)"
-    r"(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?"
-    r"(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"
-)
-
-
-def normalize_version(v: str) -> str:
-    """Normalize version string by recursively stripping 'v' or 'V' prefix.
-
-    Args:
-        v: The version string to normalize.
-
-    Returns:
-        The normalized version string without 'v' prefix.
-    """
-    while v.lower().startswith("v"):
-        v = v[1:]
-    return v
-
-
-# Annotated type that validates SemVer regex (allowing multiple v) then normalizes to strict SemVer (no v)
-VersionStr = Annotated[
-    str,
-    Field(pattern=SEMVER_REGEX),
-    AfterValidator(normalize_version),
-]
-
-# Reusable immutable dictionary type
-ImmutableDict = Annotated[
-    Mapping[str, Any],
-    AfterValidator(lambda x: MappingProxyType(x)),
-    PlainSerializer(lambda x: dict(x), return_type=Dict[str, Any]),
-]
-
-
-# Strict URI type that serializes to string
-StrictUri = Annotated[
-    AnyUrl,
-    PlainSerializer(lambda x: str(x), return_type=str),
-]
-
-
-class AgentMetadata(BaseModel):
-    """Metadata for the Agent.
-
-    Attributes:
-        id: Unique Identifier for the Agent (UUID).
-        version: Semantic Version of the Agent.
-        name: Name of the Agent.
-        author: Author of the Agent.
-        created_at: Creation timestamp (ISO 8601).
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    id: UUID = Field(..., description="Unique Identifier for the Agent (UUID).")
-    version: VersionStr = Field(..., description="Semantic Version of the Agent.")
-    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):
-    """Interface definition for the Agent.
-
-    Attributes:
-        inputs: Typed arguments the agent accepts (JSON Schema).
-        outputs: Typed structure of the result.
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    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 ModelConfig(BaseModel):
-    """LLM Configuration parameters.
-
-    Attributes:
-        model: The LLM model identifier.
-        temperature: Temperature for generation.
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    model: str = Field(..., description="The LLM model identifier.")
-    temperature: float = Field(..., ge=0.0, le=2.0, description="Temperature for generation.")
-
-
-class AgentRuntimeConfig(BaseModel):
-    """Configuration of the Agent execution.
-
-    Attributes:
-        nodes: A collection of execution units (Agents, Tools, Logic).
-        edges: Directed connections defining control flow.
-        entry_point: The ID of the starting node.
-        llm_config: Specific LLM parameters.
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    nodes: List[Node] = Field(..., description="A collection of execution units.")
-    edges: List[Edge] = Field(..., description="Directed connections defining control flow.")
-    entry_point: str = Field(..., description="The ID of the starting node.")
-    llm_config: ModelConfig = Field(..., alias="model_config", description="Specific LLM parameters.")
-
-    @field_validator("nodes")
-    @classmethod
-    def validate_unique_node_ids(cls, v: List[Node]) -> List[Node]:
-        """Ensure all node IDs are unique.
-
-        Args:
-            v: The list of nodes to validate.
-
-        Returns:
-            The validated list of nodes.
-
-        Raises:
-            ValueError: If duplicate node IDs are found.
-        """
-        ids = [node.id for node in v]
-        if len(ids) != len(set(ids)):
-            # Find duplicates
-            seen = set()
-            dupes = set()
-            for x in ids:
-                if x in seen:
-                    dupes.add(x)
-                seen.add(x)
-            raise ValueError(f"Duplicate node IDs found: {', '.join(dupes)}")
-        return v
-
-
-class ToolRiskLevel(str, Enum):
-    """Risk level for the tool."""
-
-    SAFE = "safe"
-    STANDARD = "standard"
-    CRITICAL = "critical"
-
-
-class ToolRequirement(BaseModel):
-    """Requirement for an MCP tool.
-
-    Attributes:
-        uri: The MCP endpoint URI.
-        hash: Integrity check for the tool definition (SHA256).
-        scopes: List of permissions required.
-        risk_level: The risk level of the tool.
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    uri: StrictUri = Field(..., description="The MCP endpoint URI.")
-    hash: str = Field(
-        ..., pattern=r"^[a-fA-F0-9]{64}$", description="Integrity check for the tool definition (SHA256)."
-    )
-    scopes: List[str] = Field(..., description="List of permissions required.")
-    risk_level: ToolRiskLevel = Field(..., description="The risk level of the tool.")
-
-
-class AgentDependencies(BaseModel):
-    """External dependencies for the Agent.
-
-    Attributes:
-        tools: List of MCP tool requirements.
-        libraries: List of Python packages required (if code execution is allowed).
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    tools: List[ToolRequirement] = Field(default_factory=list, description="List of MCP tool requirements.")
-    libraries: Tuple[str, ...] = Field(
-        default_factory=tuple, description="List of Python packages required (if code execution is allowed)."
-    )
-
-
-class PolicyConfig(BaseModel):
-    """Governance policy configuration.
-
-    Attributes:
-        budget_caps: Dictionary defining budget limits (e.g., {"total_cost": 10.0, "total_tokens": 1000}).
-        human_in_the_loop: List of Node IDs that require human approval.
-        allowed_domains: List of allowed domains for external access.
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    budget_caps: Dict[str, float] = Field(default_factory=dict, description="Budget limits.")
-    human_in_the_loop: List[str] = Field(default_factory=list, description="Node IDs requiring human approval.")
-    allowed_domains: List[str] = Field(default_factory=list, description="Allowed domains for external access.")
-
-
-class TraceLevel(str, Enum):
-    """Level of tracing detail."""
-
-    FULL = "full"
-    METADATA_ONLY = "metadata_only"
-    NONE = "none"
-
-
-class ObservabilityConfig(BaseModel):
-    """Observability configuration.
-
-    Attributes:
-        trace_level: Level of tracing detail.
-        retention_policy: Retention policy identifier (e.g., '30_days').
-        encryption_key_id: Optional ID of the key used for log encryption.
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    trace_level: TraceLevel = Field(default=TraceLevel.FULL, description="Level of tracing detail.")
-    retention_policy: str = Field(default="30_days", description="Retention policy identifier.")
-    encryption_key_id: Optional[str] = Field(None, description="Optional ID of the key used for log encryption.")
-
-
-class AgentDefinition(BaseModel):
-    """The Root Object for the CoReason Agent Manifest.
-
-    Attributes:
-        metadata: Metadata for the Agent.
-        interface: Interface definition for the Agent.
-        config: Configuration of the Agent execution.
-        dependencies: External dependencies for the Agent.
-        integrity_hash: SHA256 hash of the source code.
-    """
-
-    model_config = ConfigDict(
-        extra="forbid",
-        frozen=True,
-        title="CoReason Agent Manifest",
-        json_schema_extra={
-            "$id": "https://coreason.ai/schemas/agent.schema.json",
-            "description": "The definitive source of truth for CoReason Agent definitions.",
-        },
-    )
-
-    metadata: AgentMetadata
-    interface: AgentInterface
-    config: AgentRuntimeConfig
-    dependencies: AgentDependencies
-    policy: Optional[PolicyConfig] = Field(None, description="Governance policy configuration.")
-    observability: Optional[ObservabilityConfig] = Field(None, description="Observability configuration.")
-    integrity_hash: str = Field(
-        ...,
-        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/definitions/audit.py

@@ -1,122 +0,0 @@
-import hashlib
-import json
-from datetime import datetime
-from enum import Enum
-from typing import Any, Dict, List, Optional
-from uuid import UUID
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from .message import ChatMessage
-
-
-class GenAITokenUsage(BaseModel):
-    """Token consumption stats aligned with OTel conventions."""
-
-    model_config = ConfigDict(extra="ignore")
-
-    input: int = Field(0, description="Number of input tokens (prompt).")
-    output: int = Field(0, description="Number of output tokens (completion).")
-    total: int = Field(0, description="Total number of tokens used.")
-
-    # Backward compatibility fields (mapped to new fields in logic if needed, but kept for schema)
-    prompt_tokens: int = 0
-    completion_tokens: int = 0
-    total_tokens: int = 0
-    details: Dict[str, Any] = Field(default_factory=dict)
-
-
-class GenAIOperation(BaseModel):
-    """An atomic operation in the reasoning process (e.g., one LLM call), aligning with OTel Spans."""
-
-    model_config = ConfigDict(extra="ignore")
-
-    span_id: str = Field(..., description="Unique identifier for the operation/span.")
-    trace_id: str = Field(..., description="Trace ID this operation belongs to.")
-    parent_id: Optional[str] = Field(None, description="Parent span ID.")
-
-    operation_name: str = Field(..., description="Name of the operation (e.g., chat, embedding).")
-    provider: str = Field(..., description="GenAI provider (e.g., openai, anthropic).")
-    model: str = Field(..., description="Model name used.")
-
-    start_time: datetime = Field(default_factory=datetime.now)
-    end_time: Optional[datetime] = None
-    duration_ms: float = 0.0
-
-    # Context
-    input_messages: List[ChatMessage] = Field(default_factory=list)
-    output_messages: List[ChatMessage] = Field(default_factory=list)
-
-    # Metrics
-    token_usage: Optional[GenAITokenUsage] = None
-
-    # Metadata
-    status: str = "pending"  # success, error
-    error_type: Optional[str] = None
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-
-
-class ReasoningTrace(BaseModel):
-    """The full audit trail of an Agent's execution session.
-
-    Aligned with OpenTelemetry for trace identification.
-    """
-
-    model_config = ConfigDict(extra="ignore")
-
-    trace_id: str = Field(..., description="Trace ID (OTel format).")
-    agent_id: str
-    session_id: Optional[str] = None
-
-    start_time: datetime
-    end_time: Optional[datetime] = None
-
-    # The chain of thought (Ordered list of operations)
-    steps: List[GenAIOperation] = Field(default_factory=list)
-
-    # Final outcome
-    status: str = "pending"  # options: success, failure, pending
-    final_result: Optional[str] = None
-    error: Optional[str] = None
-
-    # Aggregated stats
-    total_tokens: GenAITokenUsage = Field(default_factory=GenAITokenUsage)
-    total_cost: float = 0.0
-
-
-class AuditEventType(str, Enum):
-    SYSTEM_CHANGE = "system_change"
-    PREDICTION = "prediction"
-    GUARDRAIL_TRIGGER = "guardrail_trigger"
-
-
-class AuditLog(BaseModel):
-    """Tamper-evident legal record.
-
-    IDs aligned with OpenTelemetry:
-    - audit_id: Unique record ID.
-    - trace_id: OTel Trace ID.
-    """
-
-    audit_id: UUID = Field(..., description="Unique identifier.")
-    trace_id: str = Field(..., description="Trace ID for OTel correlation.")
-    timestamp: datetime = Field(..., description="ISO8601 timestamp.")
-    actor: str = Field(..., description="User ID or Agent Component ID.")
-    event_type: AuditEventType = Field(..., description="Type of event.")
-    safety_metadata: Dict[str, Any] = Field(..., description="Safety metadata (e.g., PII detected).")
-    previous_hash: str = Field(..., description="Hash of the previous log entry.")
-    integrity_hash: str = Field(..., description="SHA256 hash of this record + previous_hash.")
-
-    def compute_hash(self) -> str:
-        """Computes the integrity hash of the record."""
-        # Use model_dump to get a dict, but exclude integrity_hash as it is the target
-        data = self.model_dump(exclude={"integrity_hash"}, mode="json")
-        # Ensure deterministic serialization
-        json_str = json.dumps(data, sort_keys=True, default=str)
-        return hashlib.sha256(json_str.encode("utf-8")).hexdigest()
-
-
-# --- Backward Compatibility ---
-# Adapters or Aliases
-CognitiveStep = GenAIOperation
-TokenUsage = GenAITokenUsage