coreason-manifest 0.10.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

{coreason_manifest-0.10.0.dist-info → coreason_manifest-0.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreason_manifest
-Version: 0.10.0
+Version: 0.13.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,7 +67,7 @@ Requires-Python: >=3.12
 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,31 +87,25 @@ The definitive source of truth for CoReason-AI Asset definitions. "The Blueprint
 
 ## Overview
 
-`coreason-manifest` serves as the **Shared Kernel** for the Coreason ecosystem. It contains the canonical Pydantic definitions, schemas, and data structures for Agents, Workflows (Recipes), and Auditing.
+`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):** Strict Pydantic models for Agent definitions (`AgentDefinition`).
-*   **Strict Typing:** Enforces type safety and immutable structures for critical interfaces.
-*   **Enhanced Serialization:** Includes `CoReasonBaseModel` to ensure consistent JSON serialization of complex types like `UUID` and `datetime`.
-*   **Event Protocol:** Defines the `GraphEvent` and `CloudEvent` structures for real-time communication.
-*   **Simulation Schemas:** Provides standard models for `SimulationScenario`, `AdversaryProfile`, and `SimulationTrace`.
-*   **Audit & Compliance:** Defines the `AuditLog` structure for tamper-evident record keeping.
-*   **Ergonomic Factory Methods:** Simplified construction of `ChatMessage` and `GenAIOperation`.
-*   **Token Arithmetic:** Support for `+` and `+=` operators on `GenAITokenUsage`.
-*   **Flexible Tooling:** `ToolCallRequestPart` accepts JSON strings with automatic parsing.
-*   **Enhanced Tracing:** `ReasoningTrace` includes flexible metadata for execution state.
+*   **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
 
-All core definitions (`AgentDefinition`, `RecipeManifest`, `GraphTopology`, `AuditLog`) inherit from `CoReasonBaseModel`. This provides a consistent interface for serialization, solving common Pydantic v2 issues with `UUID` and `datetime`.
-
-*   Use `.dump()` to get a JSON-compatible dictionary (where UUIDs/datetimes are strings).
-*   Use `.to_json()` to get a JSON string.
-
-For a detailed rationale, see [docs/coreason_base_model_rationale.md](docs/coreason_base_model_rationale.md).
+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
 
@@ -124,75 +118,57 @@ pip install coreason-manifest
 This library is used to define and validate Agent configurations programmatically.
 
 ```python
-import uuid
-from datetime import datetime, timezone
-from coreason_manifest.definitions.agent import (
-    AgentDefinition,
-    AgentMetadata,
-    AgentInterface,
-    AgentRuntimeConfig,
-    ModelConfig,
-    AgentDependencies,
-    ToolRequirement,
-    ToolRiskLevel,
-    PolicyConfig,
-    ObservabilityConfig,
-    TraceLevel
+from coreason_manifest import (
+    Recipe,
+    ManifestMetadata,
+    AgentStep,
+    Workflow,
+    InterfaceDefinition,
+    StateDefinition,
+    PolicyDefinition
 )
 
 # 1. Define Metadata
-metadata = AgentMetadata(
-    id=uuid.uuid4(),
-    version="1.0.0",  # Strict SemVer
+metadata = ManifestMetadata(
     name="Research Agent",
-    author="Coreason AI",
-    created_at=datetime.now(timezone.utc)
+    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
+    }
 )
 
-# 2. Instantiate Agent
-agent = AgentDefinition(
+# 3. Instantiate Manifest
+manifest = Recipe(
+    apiVersion="coreason.ai/v2",
+    kind="Recipe",
     metadata=metadata,
-    interface=AgentInterface(
+    interface=InterfaceDefinition(
         inputs={"topic": {"type": "string"}},
         outputs={"summary": {"type": "string"}}
     ),
-    config=AgentRuntimeConfig(
-        model_config=ModelConfig(
-            model="gpt-4",
-            temperature=0.0,
-            system_prompt="You are a helpful assistant."
-        )
-    ),
-    dependencies=AgentDependencies(
-        tools=[
-            ToolRequirement(
-                uri="mcp://search-service/google",
-                hash="e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",  # Valid SHA256
-                scopes=["search:read"],
-                risk_level=ToolRiskLevel.STANDARD
-            )
-        ],
-        libraries=("pandas==2.0.0",)
-    ),
-    policy=PolicyConfig(
-        budget_caps={"total_cost": 5.0}
-    ),
-    observability=ObservabilityConfig(
-        trace_level=TraceLevel.FULL,
-        retention_policy="90_days"
-    ),
-    # Mandatory Integrity Hash
-    integrity_hash="e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    state=StateDefinition(),
+    policy=PolicyDefinition(max_retries=3),
+    workflow=workflow
 )
 
-print(f"Agent '{agent.metadata.name}' definition created and validated.")
+print(f"Manifest '{manifest.metadata.name}' created successfully.")
 ```
 
 For full details, see the [Usage Documentation](docs/usage.md).
 
 ## Documentation
 
-*   [Frontend Integration](docs/frontend_integration.md): Communicating with the Coreason Engine.
-*   [Simulation Architecture](docs/simulation_architecture.md): Details on ATIF compatibility and GAIA scenarios.
-*   [Audit & Compliance](docs/audit_compliance.md): Details on EU AI Act compliance, Chain of Custody, and Integrity Hashing.
+*   [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.13.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+coreason_manifest/__init__.py,sha256=qy8VLZO7M4S_PWl4PB7PIztcPd_JgvKUW64S3oty0UY,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=Y9j1W0rFAh5lMAJbgMnqnyu9XmvgYdW895N5NeLvee0,461
+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.13.0.dist-info/METADATA,sha256=D4Hltcoz_4efVfP6PO3zG3H5gewSn5seUbOqjmCx54c,8228
+coreason_manifest-0.13.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+coreason_manifest-0.13.0.dist-info/licenses/LICENSE,sha256=3tYb7ZQe7sVXcbNmX22fDESFjOSIlCZodUGpZMkuSlk,3063
+coreason_manifest-0.13.0.dist-info/licenses/NOTICE,sha256=tqzUyP9VTCGxoHLgBI0AC1i0G7m_PSyESFL8Jwuw0dA,610
+coreason_manifest-0.13.0.dist-info/RECORD,,

coreason_manifest/definitions/__init__.py

@@ -1,60 +0,0 @@
-# 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-manifest
-
-from .agent import AgentDefinition, AgentRuntimeConfig, Persona
-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",
-    "Persona",
-    "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,370 +0,0 @@
-# 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-manifest
-
-"""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, Literal, Mapping, Optional, Tuple, Union
-from uuid import UUID
-
-from pydantic import (
-    AfterValidator,
-    AnyUrl,
-    ConfigDict,
-    Field,
-    PlainSerializer,
-    field_validator,
-    model_validator,
-)
-from typing_extensions import Annotated
-
-from coreason_manifest.definitions.base import CoReasonBaseModel
-from coreason_manifest.definitions.topology import Edge, Node, validate_edge_integrity
-
-# 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(CoReasonBaseModel):
-    """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 Persona(CoReasonBaseModel):
-    """Definition of an Agent Persona.
-
-    Attributes:
-        name: Name of the persona.
-        description: Description of the persona.
-        directives: List of specific instructions or directives.
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    name: str = Field(..., description="Name of the persona.")
-    description: str = Field(..., description="Description of the persona.")
-    directives: List[str] = Field(..., description="List of specific instructions or directives.")
-
-
-class AgentInterface(CoReasonBaseModel):
-    """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(CoReasonBaseModel):
-    """LLM Configuration parameters.
-
-    Attributes:
-        model: The LLM model identifier.
-        temperature: Temperature for generation.
-        system_prompt: The default system prompt/persona for the agent.
-        persona: The full persona definition (name, description, directives).
-    """
-
-    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.")
-    system_prompt: Optional[str] = Field(None, description="The default system prompt/persona for the agent.")
-    persona: Optional[Persona] = Field(None, description="The full persona definition (name, description, directives).")
-
-
-class AgentRuntimeConfig(CoReasonBaseModel):
-    """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(default_factory=list, description="A collection of execution units.")
-    edges: List[Edge] = Field(default_factory=list, description="Directed connections defining control flow.")
-    entry_point: Optional[str] = Field(None, description="The ID of the starting node.")
-    llm_config: ModelConfig = Field(..., alias="model_config", description="Specific LLM parameters.")
-    system_prompt: Optional[str] = Field(None, description="The global system prompt/instruction for the agent.")
-
-    @model_validator(mode="after")
-    def validate_topology_or_atomic(self) -> AgentRuntimeConfig:
-        """Ensure valid configuration: either a Graph or an Atomic Agent."""
-        has_nodes = len(self.nodes) > 0
-        has_entry = self.entry_point is not None
-
-        if has_nodes:
-            if not has_entry:
-                raise ValueError("Graph execution requires an 'entry_point'.")
-        else:
-            # Atomic Agent: Must have a system prompt (either global or in model_config)
-            has_global_prompt = self.system_prompt is not None
-            has_model_prompt = self.llm_config.system_prompt is not None
-
-            if not (has_global_prompt or has_model_prompt):
-                raise ValueError("Atomic Agents require a system_prompt (global or in model_config).")
-
-        return self
-
-    @model_validator(mode="after")
-    def validate_topology_integrity(self) -> AgentRuntimeConfig:
-        """Ensure that edges connect existing nodes."""
-        validate_edge_integrity(self.nodes, self.edges)
-        return self
-
-    @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(CoReasonBaseModel):
-    """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 InlineToolDefinition(CoReasonBaseModel):
-    """Definition of an inline tool.
-
-    Attributes:
-        name: Name of the tool.
-        description: Description of the tool.
-        parameters: JSON Schema of parameters.
-        type: The type of the tool (must be 'function').
-    """
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    name: str = Field(..., description="Name of the tool.")
-    description: str = Field(..., description="Description of the tool.")
-    parameters: Dict[str, Any] = Field(..., description="JSON Schema of parameters.")
-    type: Literal["function"] = Field("function", description="The type of the tool (must be 'function').")
-
-
-class AgentDependencies(CoReasonBaseModel):
-    """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[Union[ToolRequirement, InlineToolDefinition]] = 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(CoReasonBaseModel):
-    """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(CoReasonBaseModel):
-    """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(CoReasonBaseModel):
-    """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.")
-    custom_metadata: Optional[Dict[str, Any]] = Field(
-        None, description="Container for arbitrary metadata extensions without breaking validation."
-    )
-    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