ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/schemas/infrastructure/base.py

@@ -0,0 +1,256 @@
+"""
+Schemas for infrastructure base operations.
+
+These replace all Dict[str, Any] usage in protocols/infrastructure/base.py.
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class RuntimeStats(BaseModel):
+    """Runtime statistics and metrics."""
+
+    uptime_seconds: float = Field(..., description="Runtime uptime in seconds")
+    total_messages_processed: int = Field(0, description="Total messages processed")
+    active_tasks: int = Field(0, description="Number of active tasks")
+    memory_usage_mb: float = Field(..., description="Memory usage in MB")
+    cpu_usage_percent: float = Field(..., description="CPU usage percentage")
+    last_checkpoint: Optional[datetime] = Field(None, description="Last checkpoint time")
+    errors_last_hour: int = Field(0, description="Errors in last hour")
+    warnings_last_hour: int = Field(0, description="Warnings in last hour")
+    agent_state: str = Field(..., description="Current agent state")
+    additional_stats: Dict[str, Union[str, int, float, bool]] = Field(
+        default_factory=dict, description="Additional runtime stats"
+    )
+
+
+class HealthCheckResult(BaseModel):
+    """Health check result for a component."""
+
+    component_name: str = Field(..., description="Name of the component")
+    healthy: bool = Field(..., description="Whether component is healthy")
+    message: Optional[str] = Field(None, description="Health status message")
+    last_check: datetime = Field(..., description="Last health check time")
+    details: Optional[Dict[str, Union[str, int, float, bool]]] = Field(None, description="Additional health details")
+
+
+class ComponentHealthStatus(BaseModel):
+    """Overall health status of all components."""
+
+    overall_healthy: bool = Field(..., description="Whether all components are healthy")
+    components: Dict[str, bool] = Field(..., description="Health status by component name")
+    unhealthy_components: List[str] = Field(default_factory=list, description="List of unhealthy components")
+    last_check: datetime = Field(..., description="Last health check time")
+    details: List[HealthCheckResult] = Field(default_factory=list, description="Detailed health results")
+
+
+class ServiceDependencies(BaseModel):
+    """Service dependency validation results."""
+
+    all_satisfied: bool = Field(..., description="Whether all dependencies are satisfied")
+    dependencies: Dict[str, List[str]] = Field(..., description="Dependencies by service name")
+    missing_dependencies: Dict[str, List[str]] = Field(
+        default_factory=dict, description="Missing dependencies by service"
+    )
+    circular_dependencies: List[str] = Field(default_factory=list, description="Detected circular dependencies")
+    validation_time: datetime = Field(..., description="When validation was performed")
+
+
+class BusMetrics(BaseModel):
+    """Message bus performance metrics."""
+
+    messages_sent: int = Field(0, description="Total messages sent")
+    messages_received: int = Field(0, description="Total messages received")
+    messages_dropped: int = Field(0, description="Messages dropped")
+    average_latency_ms: float = Field(0.0, description="Average message latency")
+    active_subscriptions: int = Field(0, description="Number of active subscriptions")
+    queue_depth: int = Field(0, description="Current queue depth")
+    errors_last_hour: int = Field(0, description="Bus errors in last hour")
+    busiest_service: Optional[str] = Field(None, description="Service with most traffic")
+    additional_metrics: Dict[str, Union[str, int, float, bool]] = Field(
+        default_factory=dict, description="Additional bus metrics"
+    )
+
+
+class DreamConsolidationResult(BaseModel):
+    """Result of memory consolidation during dream state."""
+
+    dream_id: str = Field(..., description="Dream session ID")
+    memories_processed: int = Field(0, description="Number of memories processed")
+    memories_consolidated: int = Field(0, description="Number of memories consolidated")
+    memories_pruned: int = Field(0, description="Number of memories pruned")
+    patterns_detected: int = Field(0, description="Number of patterns detected")
+    insights_generated: int = Field(0, description="Number of insights generated")
+    duration_seconds: float = Field(..., description="Consolidation duration")
+    success: bool = Field(..., description="Whether consolidation succeeded")
+    errors: List[str] = Field(default_factory=list, description="Errors during consolidation")
+
+
+class DreamSchedule(BaseModel):
+    """Dream processing schedule information."""
+
+    next_dream_time: Optional[datetime] = Field(None, description="Next scheduled dream")
+    last_dream_time: Optional[datetime] = Field(None, description="Last dream time")
+    dream_frequency_hours: float = Field(24.0, description="Hours between dreams")
+    is_dreaming: bool = Field(False, description="Currently in dream state")
+    current_dream_id: Optional[str] = Field(None, description="Current dream ID if dreaming")
+    dreams_completed: int = Field(0, description="Total dreams completed")
+    average_dream_duration_minutes: float = Field(0.0, description="Average dream duration")
+
+
+class DreamInsight(BaseModel):
+    """Insight discovered during dream analysis."""
+
+    insight_id: str = Field(..., description="Unique insight ID")
+    insight_type: str = Field(..., description="Type of insight")
+    description: str = Field(..., description="Insight description")
+    supporting_memories: List[str] = Field(default_factory=list, description="Memory IDs supporting this insight")
+    timestamp: datetime = Field(..., description="When insight was discovered")
+    metadata: Dict[str, Union[str, int, float, bool]] = Field(
+        default_factory=dict, description="Additional insight metadata"
+    )
+
+
+class IdentityBaseline(BaseModel):
+    """Identity baseline for variance monitoring."""
+
+    baseline_id: str = Field(..., description="Baseline ID")
+    created_at: datetime = Field(..., description="When baseline was created")
+    core_values: List[str] = Field(..., description="Core value identifiers")
+    behavioral_patterns: Dict[str, float] = Field(..., description="Behavioral pattern scores")
+    decision_weights: Dict[str, float] = Field(..., description="Decision making weights")
+    memory_priorities: List[str] = Field(..., description="Memory priority types")
+    baseline_hash: str = Field(..., description="Hash of baseline for integrity")
+    metadata: Dict[str, Union[str, int, float, bool]] = Field(
+        default_factory=dict, description="Additional baseline data"
+    )
+
+
+class IdentityVarianceMetric(BaseModel):
+    """Identity variance measurement."""
+
+    measurement_time: datetime = Field(..., description="When measurement was taken")
+    variance_percentage: float = Field(..., description="Variance from baseline percentage")
+    changed_values: List[str] = Field(default_factory=list, description="Values that changed")
+    behavioral_drift: Dict[str, float] = Field(default_factory=dict, description="Behavioral pattern changes")
+    decision_drift: Dict[str, float] = Field(default_factory=dict, description="Decision weight changes")
+    within_threshold: bool = Field(..., description="Whether variance is within acceptable threshold")
+    alert_triggered: bool = Field(False, description="Whether alert was triggered")
+
+
+class ConfigurationFeedback(BaseModel):
+    """Configuration feedback data."""
+
+    feedback_id: str = Field(..., description="Feedback ID")
+    timestamp: datetime = Field(..., description="When feedback was collected")
+    configuration_item: str = Field(..., description="Configuration item")
+    performance_score: float = Field(..., description="Performance score 0-1")
+    error_rate: float = Field(..., description="Error rate percentage")
+    user_satisfaction: Optional[float] = Field(None, description="User satisfaction score")
+    suggested_adjustment: Optional[str] = Field(None, description="Suggested configuration adjustment")
+    metadata: Dict[str, Union[str, int, float, bool]] = Field(
+        default_factory=dict, description="Additional feedback data"
+    )
+
+
+class ConfigurationPattern(BaseModel):
+    """Detected configuration pattern."""
+
+    pattern_id: str = Field(..., description="Pattern ID")
+    pattern_type: str = Field(..., description="Type of pattern")
+    frequency: int = Field(..., description="How often pattern occurs")
+    success_rate: float = Field(..., description="Success rate when pattern active")
+    configuration_items: List[str] = Field(..., description="Configuration items in pattern")
+    recommended_action: str = Field(..., description="Recommended action for pattern")
+
+
+class ConfigurationUpdate(BaseModel):
+    """Proposed configuration update."""
+
+    update_id: str = Field(..., description="Update ID")
+    proposed_at: datetime = Field(..., description="When update was proposed")
+    configuration_item: str = Field(..., description="Item to update")
+    current_value: str = Field(..., description="Current value")
+    proposed_value: str = Field(..., description="Proposed new value")
+    rationale: str = Field(..., description="Why this update is recommended")
+    expected_improvement: float = Field(..., description="Expected improvement percentage")
+    risk_score: float = Field(..., description="Risk score 0-1")
+    approved: bool = Field(False, description="Whether update is approved")
+
+
+class ActiveAdapter(BaseModel):
+    """Information about an active adapter."""
+
+    adapter_type: str = Field(..., description="Type of adapter")
+    adapter_id: str = Field(..., description="Unique adapter ID")
+    status: str = Field(..., description="Adapter status")
+    started_at: datetime = Field(..., description="When adapter was started")
+    messages_handled: int = Field(0, description="Messages handled by adapter")
+    last_activity: Optional[datetime] = Field(None, description="Last activity time")
+    configuration: Dict[str, Union[str, int, float, bool]] = Field(
+        default_factory=dict, description="Adapter configuration"
+    )
+
+
+class CheckpointInfo(BaseModel):
+    """Information about a system checkpoint."""
+
+    checkpoint_id: str = Field(..., description="Checkpoint ID")
+    created_at: datetime = Field(..., description="When checkpoint was created")
+    size_bytes: int = Field(..., description="Checkpoint size in bytes")
+    description: str = Field(..., description="Checkpoint description")
+    agent_state: str = Field(..., description="Agent state at checkpoint")
+    includes_memory: bool = Field(True, description="Whether memory is included")
+    includes_config: bool = Field(True, description="Whether config is included")
+    metadata: Dict[str, Union[str, int, float, bool]] = Field(
+        default_factory=dict, description="Additional checkpoint metadata"
+    )
+
+
+class ServiceRegistration(BaseModel):
+    """Service registration information."""
+
+    service_name: str = Field(..., description="Service name")
+    service_type: str = Field(..., description="Service type")
+    registered_at: datetime = Field(..., description="Registration time")
+    status: str = Field(..., description="Service status")
+    endpoints: List[str] = Field(default_factory=list, description="Service endpoints")
+    capabilities: List[str] = Field(default_factory=list, description="Service capabilities")
+    dependencies: List[str] = Field(default_factory=list, description="Service dependencies")
+    health_check_url: Optional[str] = Field(None, description="Health check endpoint")
+    metadata: Dict[str, Union[str, int, float, bool]] = Field(
+        default_factory=dict, description="Additional service metadata"
+    )
+
+
+class ServiceRegistrySnapshot(BaseModel):
+    """Snapshot of the service registry state for serialization."""
+
+    services: Dict[str, ServiceRegistration] = Field(..., description="All registered services")
+    total_services: int = Field(..., description="Total number of services")
+    healthy_services: int = Field(..., description="Number of healthy services")
+    last_update: datetime = Field(..., description="Last registry update")
+
+
+__all__ = [
+    "RuntimeStats",
+    "HealthCheckResult",
+    "ComponentHealthStatus",
+    "ServiceDependencies",
+    "BusMetrics",
+    "DreamConsolidationResult",
+    "DreamSchedule",
+    "DreamInsight",
+    "IdentityBaseline",
+    "IdentityVarianceMetric",
+    "ConfigurationFeedback",
+    "ConfigurationPattern",
+    "ConfigurationUpdate",
+    "ActiveAdapter",
+    "CheckpointInfo",
+    "ServiceRegistration",
+    "ServiceRegistrySnapshot",
+]

ciris_engine/schemas/infrastructure/behavioral_patterns.py

@@ -0,0 +1,129 @@
+"""
+Schemas for identity variance and behavioral pattern tracking.
+
+Provides typed schemas in identity_variance_monitor.py and configuration_feedback_loop.py.
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
+
+
+class BehavioralPattern(BaseModel):
+    """A detected behavioral pattern from agent history."""
+
+    pattern_type: str = Field(..., description="Type of pattern: action_frequency, response_style, etc.")
+    frequency: float = Field(..., description="How often this pattern occurs (0.0-1.0)")
+    evidence: List[str] = Field(default_factory=list, description="Evidence supporting this pattern")
+    first_seen: datetime = Field(..., description="When pattern was first observed")
+    last_seen: datetime = Field(..., description="Most recent occurrence")
+
+    model_config = ConfigDict()
+
+    @field_serializer("first_seen", "last_seen")
+    def serialize_datetime(self, dt: datetime) -> str:
+        return dt.isoformat()
+
+
+class ActionFrequency(BaseModel):
+    """Tracks frequency of specific actions."""
+
+    action: str = Field(..., description="Action type being tracked")
+    count: int = Field(0, description="Number of occurrences")
+    evidence: List[str] = Field(default_factory=list, description="Recent examples")
+    last_seen: datetime = Field(..., description="Most recent occurrence")
+    daily_average: Optional[float] = Field(None, description="Average occurrences per day")
+
+    model_config = ConfigDict()
+
+    @field_serializer("last_seen")
+    def serialize_datetime(self, dt: datetime) -> str:
+        return dt.isoformat()
+
+
+class EthicalBoundary(BaseModel):
+    """Represents an ethical boundary configuration."""
+
+    boundary_type: str = Field(..., description="Type of boundary: harm_prevention, autonomy, etc.")
+    threshold: float = Field(..., description="Configured threshold value")
+    current_value: float = Field(..., description="Current measured value")
+    is_violated: bool = Field(False, description="Whether boundary is currently violated")
+    violation_count: int = Field(0, description="Number of violations detected")
+    last_violation: Optional[datetime] = Field(None, description="Most recent violation")
+
+    model_config = ConfigDict()
+
+    @field_serializer("last_violation")
+    def serialize_datetime(self, dt: Optional[datetime]) -> Optional[str]:
+        return dt.isoformat() if dt else None
+
+
+class IdentityMetric(BaseModel):
+    """A single identity variance metric."""
+
+    metric_name: str = Field(..., description="Name of the metric")
+    baseline_value: float = Field(..., description="Expected baseline value")
+    current_value: float = Field(..., description="Current measured value")
+    variance: float = Field(..., description="Variance from baseline (percentage)")
+    is_within_bounds: bool = Field(..., description="Whether variance is acceptable")
+    timestamp: datetime = Field(..., description="When measurement was taken")
+
+    model_config = ConfigDict()
+
+    @field_serializer("timestamp")
+    def serialize_datetime(self, dt: datetime) -> str:
+        return dt.isoformat()
+
+
+class IdentityVarianceReport(BaseModel):
+    """Complete identity variance analysis report."""
+
+    timestamp: datetime = Field(..., description="Report generation time")
+    overall_variance: float = Field(..., description="Overall variance percentage")
+    is_stable: bool = Field(..., description="Whether identity is stable")
+    metrics: List[IdentityMetric] = Field(default_factory=list, description="Individual metrics")
+    behavioral_patterns: List[BehavioralPattern] = Field(default_factory=list, description="Detected patterns")
+    ethical_boundaries: List[EthicalBoundary] = Field(default_factory=list, description="Ethical boundary status")
+    recommendations: List[str] = Field(default_factory=list, description="Recommended adjustments")
+
+    model_config = ConfigDict()
+
+    @field_serializer("timestamp")
+    def serialize_datetime(self, dt: datetime) -> str:
+        return dt.isoformat()
+
+
+class TemporalPattern(BaseModel):
+    """A time-based pattern detected in agent behavior."""
+
+    pattern_id: str = Field(..., description="Unique pattern identifier")
+    pattern_type: str = Field(..., description="Type: daily, weekly, hourly")
+    time_window: str = Field(..., description="Time window (e.g., '09:00-17:00', 'monday-friday')")
+    activity_description: str = Field(..., description="What happens during this time")
+    occurrence_count: int = Field(0, description="Times this pattern occurred")
+    first_detected: datetime = Field(..., description="When pattern was first detected")
+    last_observed: datetime = Field(..., description="Most recent occurrence")
+    metrics: Dict[str, float] = Field(default_factory=dict, description="Associated metrics")
+
+    model_config = ConfigDict()
+
+    @field_serializer("first_detected", "last_observed")
+    def serialize_datetime(self, dt: datetime) -> str:
+        return dt.isoformat()
+
+
+class FeedbackLoopAnalysis(BaseModel):
+    """Analysis from configuration feedback loop."""
+
+    timestamp: datetime = Field(..., description="Analysis timestamp")
+    dominant_actions: Dict[str, ActionFrequency] = Field(default_factory=dict, description="Most frequent actions")
+    underused_capabilities: List[str] = Field(default_factory=list, description="Capabilities not being used")
+    suggested_adjustments: List[str] = Field(default_factory=list, description="Recommended config changes")
+    reliability_level: float = Field(0.5, description="Reliability of recommendations (0.0-1.0)")
+
+    model_config = ConfigDict()
+
+    @field_serializer("timestamp")
+    def serialize_datetime(self, dt: datetime) -> str:
+        return dt.isoformat()

ciris_engine/schemas/infrastructure/feedback_loop.py

@@ -0,0 +1,57 @@
+"""
+Schemas for configuration feedback loop operations.
+
+These replace all Dict[str, Any] usage in logic/infrastructure/sub_services/configuration_feedback_loop.py.
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from ciris_engine.schemas.types import JSONDict
+
+
+class PatternType(str, Enum):
+    """Types of patterns we can detect."""
+
+    TEMPORAL = "temporal"  # Time-based patterns
+    FREQUENCY = "frequency"  # Usage frequency patterns
+    PERFORMANCE = "performance"  # Performance optimization patterns
+    ERROR = "error"  # Error/failure patterns
+    USER_PREFERENCE = "user_preference"  # User interaction patterns
+
+
+class PatternMetrics(BaseModel):
+    """Metrics associated with a detected pattern."""
+
+    occurrence_count: int = Field(0, description="Number of occurrences")
+    average_value: float = Field(0.0, description="Average metric value")
+    peak_value: float = Field(0.0, description="Peak metric value")
+    time_range_hours: float = Field(24.0, description="Time range analyzed")
+    data_points: int = Field(0, description="Number of data points")
+    trend: str = Field("stable", description="Trend: increasing, decreasing, stable")
+    metadata: JSONDict = Field(default_factory=dict, description="Additional metrics")
+
+
+class DetectedPattern(BaseModel):
+    """A pattern detected from metrics/telemetry."""
+
+    pattern_type: PatternType = Field(..., description="Type of pattern")
+    pattern_id: str = Field(..., description="Unique pattern identifier")
+    description: str = Field(..., description="Human-readable description")
+    evidence_nodes: List[str] = Field(default_factory=list, description="Supporting evidence node IDs")
+    detected_at: datetime = Field(..., description="When pattern was detected")
+    metrics: PatternMetrics = Field(..., description="Pattern metrics")
+
+
+class AnalysisResult(BaseModel):
+    """Result of feedback loop analysis."""
+
+    status: str = Field(..., description="Status: completed, not_due, error")
+    patterns_detected: int = Field(0, description="Number of patterns detected")
+    insights_stored: int = Field(0, description="Number of insights stored for agent introspection")
+    timestamp: datetime = Field(..., description="Analysis timestamp")
+    next_analysis_in: Optional[float] = Field(None, description="Seconds until next analysis")
+    error: Optional[str] = Field(None, description="Error message if failed")

ciris_engine/schemas/infrastructure/identity_variance.py

@@ -0,0 +1,141 @@
+"""
+Schemas for identity variance monitoring operations.
+
+These replace all Dict[str, Any] usage in logic/infrastructure/sub_services/identity_variance_monitor.py.
+"""
+
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, List, Optional, Set, Union
+
+from pydantic import BaseModel, Field
+
+from ciris_engine.schemas.types import JSONValue
+
+
+class VarianceImpact(str, Enum):
+    """Impact levels for different types of changes (not used in variance calculation)."""
+
+    CRITICAL = "critical"  # Core purpose/ethics changes
+    HIGH = "high"  # Capabilities/trust changes
+    MEDIUM = "medium"  # Behavioral patterns
+    LOW = "low"  # Preferences/templates
+
+
+class IdentityDiff(BaseModel):
+    """Represents a difference between baseline and current identity."""
+
+    node_id: str = Field(..., description="Node ID where difference found")
+    diff_type: str = Field(..., description="Type of difference: added, removed, modified")
+    impact: VarianceImpact = Field(..., description="Impact level of the change")
+    baseline_value: Optional[str] = Field(None, description="Value in baseline (serialized)")
+    current_value: Optional[str] = Field(None, description="Current value (serialized)")
+    description: str = Field(..., description="Human-readable description of difference")
+
+
+class VarianceReport(BaseModel):
+    """Complete variance analysis report."""
+
+    timestamp: datetime = Field(..., description="When analysis was performed")
+    baseline_snapshot_id: str = Field(..., description="ID of baseline snapshot")
+    current_snapshot_id: str = Field(..., description="ID of current snapshot")
+    total_variance: float = Field(..., description="Total variance percentage (simple count/total)")
+    differences: List[IdentityDiff] = Field(default_factory=list, description="List of differences found")
+    requires_wa_review: bool = Field(..., description="Whether WA review is required")
+    recommendations: List[str] = Field(default_factory=list, description="Recommended actions")
+
+
+# IdentitySnapshot moved to schemas/services/nodes.py as TypedGraphNode
+
+
+class VarianceAnalysis(BaseModel):
+    """Detailed variance analysis between snapshots."""
+
+    baseline_nodes: Set[str] = Field(default_factory=set, description="Node IDs in baseline")
+    current_nodes: Set[str] = Field(default_factory=set, description="Node IDs in current")
+    added_nodes: Set[str] = Field(default_factory=set, description="Nodes added since baseline")
+    removed_nodes: Set[str] = Field(default_factory=set, description="Nodes removed since baseline")
+    modified_nodes: Set[str] = Field(default_factory=set, description="Nodes modified since baseline")
+    variance_scores: Dict[str, float] = Field(default_factory=dict, description="Variance score by node")
+    impact_counts: Dict[VarianceImpact, int] = Field(default_factory=dict, description="Count of changes by impact")
+
+
+class WAReviewRequest(BaseModel):
+    """Request for WA review of identity variance."""
+
+    request_id: str = Field(..., description="Unique request ID")
+    timestamp: datetime = Field(..., description="When request was made")
+    current_variance: float = Field(..., description="Current variance percentage")
+    variance_report: VarianceReport = Field(..., description="Full variance report")
+    critical_changes: List[IdentityDiff] = Field(default_factory=list, description="Critical changes requiring review")
+    proposed_actions: List[str] = Field(default_factory=list, description="Proposed corrective actions")
+    urgency: str = Field("high", description="Review urgency level")
+
+
+class VarianceCheckMetadata(BaseModel):
+    """Metadata for variance check operations."""
+
+    handler_name: str = Field("identity_variance_monitor", description="Handler performing check")
+    check_type: str = Field(..., description="Type of check: scheduled, forced, triggered")
+    check_reason: Optional[str] = Field(None, description="Reason for check if triggered")
+    previous_check: Optional[datetime] = Field(None, description="Previous check timestamp")
+    baseline_established: datetime = Field(..., description="When baseline was established")
+
+
+class CurrentIdentityData(BaseModel):
+    """Structured representation of current identity state extracted from nodes."""
+
+    agent_id: str = Field("unknown", description="Agent ID")
+    identity_hash: str = Field("unknown", description="Identity hash")
+    core_purpose: str = Field("unknown", description="Core purpose description")
+    role: str = Field("unknown", description="Role description")
+    permitted_actions: List[str] = Field(default_factory=list, description="List of permitted actions")
+    restricted_capabilities: List[str] = Field(default_factory=list, description="List of restricted capabilities")
+    ethical_boundaries: List[str] = Field(default_factory=list, description="List of ethical boundaries")
+    personality_traits: List[str] = Field(default_factory=list, description="List of personality traits")
+    communication_style: str = Field("standard", description="Communication style")
+    learning_enabled: bool = Field(True, description="Whether learning is enabled")
+    adaptation_rate: float = Field(0.1, description="Rate of adaptation")
+
+
+class IdentityData(BaseModel):
+    """Identity data schema for system snapshots - sourced from local graph memory."""
+
+    agent_id: str = Field(..., description="Agent identifier")
+    description: str = Field(..., description="Agent description")
+    role: str = Field(..., description="Agent role description")
+    trust_level: float = Field(0.5, ge=0.0, le=1.0, description="Agent trust level")
+    stewardship: Optional[Union[str, JSONValue]] = Field(
+        None, description="Stewardship description or data structure if present"
+    )
+
+
+class IdentitySummary(BaseModel):
+    """Summarized identity data for system contexts - sourced from local graph memory."""
+
+    identity_purpose: Optional[str] = Field(None, description="Core identity purpose")
+    identity_capabilities: List[str] = Field(default_factory=list, description="Identity capabilities")
+    identity_restrictions: List[str] = Field(default_factory=list, description="Identity restrictions")
+
+
+class ServiceStatusMetrics(BaseModel):
+    """Custom metrics for service status reporting."""
+
+    has_baseline: float = Field(0.0, description="1.0 if baseline exists, 0.0 otherwise")
+    last_variance_check: Optional[str] = Field(None, description="ISO timestamp of last variance check")
+    variance_threshold: float = Field(0.20, description="Variance threshold for triggering WA review")
+
+
+class JSONDict(BaseModel):
+    """Generic node attributes for parsing."""
+
+    agent_id: Optional[str] = Field(None, description="Agent ID from node")
+    identity_hash: Optional[str] = Field(None, description="Identity hash from node")
+    description: Optional[str] = Field(None, description="Description field")
+    role_description: Optional[str] = Field(None, description="Role description")
+    permitted_actions: Optional[List[str]] = Field(None, description="Permitted actions")
+    restricted_capabilities: Optional[List[str]] = Field(None, description="Restricted capabilities")
+    areas_of_expertise: Optional[List[str]] = Field(None, description="Areas of expertise")
+    startup_instructions: Optional[str] = Field(None, description="Startup instructions")
+    ethical_boundaries: Optional[List[str]] = Field(None, description="Ethical boundaries")
+    node_class: Optional[str] = Field(None, description="Node class type")