ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/schemas/services/conversation_summary_node.py

@@ -0,0 +1,189 @@
+"""
+Conversation summary nodes for consolidating speak/observe correlations.
+
+These nodes preserve conversation content while consolidating metrics.
+"""
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from ciris_engine.schemas.services.graph_core import GraphNode, GraphScope, NodeType
+from ciris_engine.schemas.services.graph_typed_nodes import TypedGraphNode, register_node_type
+from ciris_engine.schemas.types import JSONDict
+
+
+class ConversationMessage(BaseModel):
+    """A single message in a conversation."""
+
+    timestamp: str = Field(..., description="ISO timestamp")
+    author_id: str = Field(..., description="Author ID")
+    author_name: str = Field(..., description="Author name")
+    content: str = Field(..., description="Message content")
+    action_type: str = Field(..., description="Action type (speak, observe, etc.)")
+    correlation_id: str = Field(..., description="Correlation ID")
+
+
+@register_node_type("CONVERSATION_SUMMARY")
+class ConversationSummaryNode(TypedGraphNode):
+    """
+    Consolidated conversation summary for a time period.
+
+    Preserves full message content from speak/observe actions while
+    summarizing metrics and patterns.
+    """
+
+    # Period information
+    period_start: datetime = Field(..., description="Start of the consolidation period")
+    period_end: datetime = Field(..., description="End of the consolidation period")
+    period_label: str = Field(..., description="Human-readable period label")
+
+    # Conversation content - CRITICAL for memory
+    conversations_by_channel: Dict[str, List[ConversationMessage]] = Field(
+        default_factory=dict, description="Full conversation history by channel"
+    )
+
+    # Message structure in conversations_by_channel:
+    # {
+    #   "channel_id": [
+    #     {
+    #       "timestamp": "2024-01-01T12:00:00Z",
+    #       "author_id": "user123",
+    #       "author_name": "Bob",
+    #       "content": "Hello CIRIS",
+    #       "action_type": "observe",
+    #       "correlation_id": "abc123"
+    #     },
+    #     {
+    #       "timestamp": "2024-01-01T12:00:05Z",
+    #       "author_id": "ciris",
+    #       "author_name": "CIRIS",
+    #       "content": "Hello Bob! How can I help?",
+    #       "action_type": "speak",
+    #       "correlation_id": "def456"
+    #     }
+    #   ]
+    # }
+
+    # Aggregated metrics
+    total_messages: int = Field(0, description="Total messages in period")
+    messages_by_channel: Dict[str, int] = Field(default_factory=dict, description="Message count per channel")
+    unique_users: int = Field(0, description="Number of unique users")
+    user_list: List[str] = Field(default_factory=list, description="List of user IDs who interacted")
+
+    # Service interaction metrics
+    action_counts: Dict[str, int] = Field(
+        default_factory=dict, description="Count of each action type (speak, observe, etc.)"
+    )
+    service_calls: Dict[str, int] = Field(default_factory=dict, description="Count of calls to each service")
+
+    # Performance metrics
+    avg_response_time_ms: float = Field(0.0, description="Average response time")
+    total_processing_time_ms: float = Field(0.0, description="Total processing time")
+    error_count: int = Field(0, description="Number of errors")
+    success_rate: float = Field(1.0, description="Success rate (0-1)")
+
+    # Conversation patterns (for future ML/analysis)
+    topic_keywords: List[str] = Field(default_factory=list, description="Extracted topic keywords")
+    sentiment_summary: Optional[Dict[str, float]] = Field(None, description="Sentiment analysis if available")
+
+    # Summary metadata
+    source_correlation_count: int = Field(0, description="Number of correlations consolidated")
+    consolidation_timestamp: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), description="When this summary was created"
+    )
+
+    # Required TypedGraphNode fields
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    created_by: str = Field(default="TSDBConsolidationService")
+    updated_by: str = Field(default="TSDBConsolidationService")
+
+    # Graph node type
+    type: NodeType = Field(default=NodeType.CONVERSATION_SUMMARY)
+    scope: GraphScope = Field(default=GraphScope.LOCAL)
+    id: str = Field(..., description="Node ID")
+    version: int = Field(default=1)
+    attributes: JSONDict = Field(default_factory=dict, description="Node attributes")
+
+    def to_graph_node(self) -> GraphNode:
+        """Convert to GraphNode for storage."""
+        extra_fields = {
+            # Period info
+            "period_start": self.period_start.isoformat(),
+            "period_end": self.period_end.isoformat(),
+            "period_label": self.period_label,
+            # CRITICAL: Full conversation content
+            "conversations_by_channel": self.conversations_by_channel,
+            # Metrics
+            "total_messages": self.total_messages,
+            "messages_by_channel": self.messages_by_channel,
+            "unique_users": self.unique_users,
+            "user_list": self.user_list,
+            "action_counts": self.action_counts,
+            "service_calls": self.service_calls,
+            # Performance
+            "avg_response_time_ms": self.avg_response_time_ms,
+            "total_processing_time_ms": self.total_processing_time_ms,
+            "error_count": self.error_count,
+            "success_rate": self.success_rate,
+            # Patterns
+            "topic_keywords": self.topic_keywords,
+            "sentiment_summary": self.sentiment_summary,
+            # Metadata
+            "source_correlation_count": self.source_correlation_count,
+            "consolidation_timestamp": self.consolidation_timestamp.isoformat(),
+            # Type hint
+            "node_class": "ConversationSummaryNode",
+        }
+
+        return GraphNode(
+            id=self.id,
+            type=self.type,
+            scope=self.scope,
+            attributes=extra_fields,
+            version=self.version,
+            updated_by=self.updated_by or "TSDBConsolidationService",
+            updated_at=self.updated_at or self.consolidation_timestamp,
+        )
+
+    @classmethod
+    def from_graph_node(cls, node: GraphNode) -> "ConversationSummaryNode":
+        """Reconstruct from GraphNode."""
+        attrs = node.attributes if isinstance(node.attributes, dict) else {}
+
+        return cls(
+            # Base fields from GraphNode
+            id=node.id,
+            type=node.type,
+            scope=node.scope,
+            version=node.version,
+            updated_by=node.updated_by,
+            updated_at=node.updated_at,
+            # Period info
+            period_start=cls._deserialize_datetime(attrs.get("period_start")),
+            period_end=cls._deserialize_datetime(attrs.get("period_end")),
+            period_label=attrs.get("period_label", ""),
+            # Conversations
+            conversations_by_channel=attrs.get("conversations_by_channel", {}),
+            # Metrics
+            total_messages=attrs.get("total_messages", 0),
+            messages_by_channel=attrs.get("messages_by_channel", {}),
+            unique_users=attrs.get("unique_users", 0),
+            user_list=attrs.get("user_list", []),
+            action_counts=attrs.get("action_counts", {}),
+            service_calls=attrs.get("service_calls", {}),
+            # Performance
+            avg_response_time_ms=attrs.get("avg_response_time_ms", 0.0),
+            total_processing_time_ms=attrs.get("total_processing_time_ms", 0.0),
+            error_count=attrs.get("error_count", 0),
+            success_rate=attrs.get("success_rate", 1.0),
+            # Patterns
+            topic_keywords=attrs.get("topic_keywords", []),
+            sentiment_summary=attrs.get("sentiment_summary"),
+            # Metadata
+            source_correlation_count=attrs.get("source_correlation_count", 0),
+            consolidation_timestamp=cls._deserialize_datetime(attrs.get("consolidation_timestamp"))
+            or datetime.now(timezone.utc),
+        )

ciris_engine/schemas/services/core/__init__.py

@@ -0,0 +1,153 @@
+"""
+Core service management schemas.
+
+Critical schemas for service container, status, and capabilities.
+"""
+
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ciris_engine.schemas.services.metadata import ServiceMetadata
+from ciris_engine.schemas.types import JSONDict
+
+if TYPE_CHECKING:
+    pass
+
+
+class ServiceCapabilities(BaseModel):
+    """Capabilities exposed by a service."""
+
+    service_name: str = Field(..., description="Name of the service")
+    actions: List[str] = Field(..., description="Actions this service can perform")
+    version: str = Field(..., description="Service version")
+    dependencies: List[str] = Field(default_factory=list, description="Required dependencies")
+    metadata: Optional[ServiceMetadata] = Field(None, description="Additional capability metadata")
+
+
+class ServiceStatus(BaseModel):
+    """Status information for any service."""
+
+    service_name: str = Field(..., description="Name of the service")
+    service_type: str = Field(..., description="Type of service")
+    is_healthy: bool = Field(..., description="Whether service is healthy")
+    uptime_seconds: float = Field(..., description="Service uptime in seconds")
+    last_error: Optional[str] = Field(None, description="Last error if any")
+    metrics: Dict[str, float] = Field(default_factory=dict, description="Service-specific metrics")
+    custom_metrics: Optional[Dict[str, float]] = Field(None, description="Additional custom metrics")
+    last_health_check: Optional[datetime] = Field(None, description="Last health check time")
+
+
+class ServiceContainer(BaseModel):
+    """Type-safe container for all CIRIS services."""
+
+    # Core services - using Any to avoid circular imports
+    llm_service: Optional[Any] = Field(None, description="LLM service for AI operations")
+    memory_service: Optional[Any] = Field(None, description="Memory service for knowledge storage")
+    audit_services: List[Any] = Field(default_factory=list, description="Audit services for compliance")
+    tool_services: List[Any] = Field(default_factory=list, description="Tool services for capabilities")
+    wa_services: List[Any] = Field(default_factory=list, description="Wise Authority services")
+
+    # Security services
+    secrets_service: Optional[Any] = Field(None, description="Secrets management service")
+    wa_auth_system: Optional[Any] = Field(None, description="WA authentication system")
+
+    # Infrastructure services
+    telemetry_service: Optional[Any] = Field(None, description="Telemetry and monitoring")
+    adaptive_filter_service: Optional[Any] = Field(None, description="Adaptive content filtering")
+    agent_config_service: Optional[Any] = Field(None, description="Agent configuration management")
+    transaction_orchestrator: Optional[Any] = Field(None, description="Transaction coordination")
+    secrets_tool_service: Optional[Any] = Field(None, description="Secrets tool capabilities")
+    maintenance_service: Optional[Any] = Field(None, description="System maintenance service")
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def get_service_by_type(self, service_type: str) -> Optional[List[Any]]:
+        """Get services by type name."""
+        service_map = {
+            "llm": [self.llm_service] if self.llm_service else [],
+            "memory": [self.memory_service] if self.memory_service else [],
+            "audit": self.audit_services,
+            "tool": self.tool_services,
+            "wise_authority": self.wa_services,
+            "secrets": [self.secrets_service] if self.secrets_service else [],
+            "wa_auth": [self.wa_auth_system] if self.wa_auth_system else [],
+            "telemetry": [self.telemetry_service] if self.telemetry_service else [],
+            "adaptive_filter": [self.adaptive_filter_service] if self.adaptive_filter_service else [],
+            "agent_config": [self.agent_config_service] if self.agent_config_service else [],
+            "transaction": [self.transaction_orchestrator] if self.transaction_orchestrator else [],
+            "secrets_tool": [self.secrets_tool_service] if self.secrets_tool_service else [],
+            "maintenance": [self.maintenance_service] if self.maintenance_service else [],
+        }
+        result = service_map.get(service_type, [])
+        return result if isinstance(result, list) else []
+
+    @property
+    def audit_service(self) -> Optional[Any]:
+        """Get primary audit service for backward compatibility."""
+        return self.audit_services[0] if self.audit_services else None
+
+
+class RuntimeMetrics(BaseModel):
+    """Runtime metrics for monitoring."""
+
+    uptime_seconds: float = Field(..., description="Total uptime")
+    tasks_processed: int = Field(..., description="Total tasks processed")
+    thoughts_generated: int = Field(..., description="Total thoughts generated")
+    decisions_made: int = Field(..., description="Total decisions made")
+    actions_performed: int = Field(..., description="Total actions performed")
+
+    # Resource usage
+    memory_usage_mb: float = Field(..., description="Memory usage in MB")
+    cpu_usage_percent: float = Field(..., description="CPU usage percentage")
+
+    # Error tracking
+    error_count: int = Field(0, description="Total errors encountered")
+    last_error: Optional[str] = Field(None, description="Last error message")
+
+    # Performance
+    average_task_duration_ms: float = Field(0.0, description="Average task duration")
+    average_thought_duration_ms: float = Field(0.0, description="Average thought duration")
+
+
+class BusMessage(BaseModel):
+    """Message sent through the service bus."""
+
+    id: str = Field(..., description="Unique message ID")
+    from_service: str = Field(..., description="Sending service")
+    to_service: str = Field(..., description="Target service")
+    action: str = Field(..., description="Action to perform")
+    payload: JSONDict = Field(..., description="Message payload")
+    correlation_id: str = Field(..., description="Correlation ID for tracing")
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    reply_to: Optional[str] = Field(None, description="Where to send reply")
+
+
+class ServiceRegistration(BaseModel):
+    """Service registration information."""
+
+    service_name: str = Field(..., description="Unique service name")
+    service_type: str = Field(..., description="Type of service")
+    capabilities: ServiceCapabilities = Field(..., description="Service capabilities")
+    dependencies: List[str] = Field(default_factory=list, description="Required services")
+    status: ServiceStatus = Field(..., description="Current status")
+    registered_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+    # Health check
+    health_check_endpoint: Optional[str] = Field(None, description="Health check endpoint")
+    last_health_check: Optional[datetime] = Field(None, description="Last health check time")
+
+
+# Re-export schemas from submodules
+
+__all__ = [
+    # Core service schemas
+    "ServiceCapabilities",
+    "ServiceStatus",
+    "ServiceContainer",
+    "RuntimeMetrics",
+    "BusMessage",
+    "ServiceRegistration",
+    # Re-exported from submodules - will be populated by star imports
+]

ciris_engine/schemas/services/core/runtime.py

@@ -0,0 +1,262 @@
+"""
+Runtime service schemas for runtime control operations.
+
+Provides typed schemas for all runtime control service responses.
+"""
+
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from ciris_engine.schemas.adapters.tools import ToolInfo
+from ciris_engine.schemas.services.runtime_control import PipelineState, StepResultData
+from ciris_engine.schemas.types import ConfigDict, JSONDict
+
+
+class AdapterStatus(str, Enum):
+    """Adapter operational status."""
+
+    ACTIVE = "active"
+    RUNNING = "running"
+    STOPPED = "stopped"
+    ERROR = "error"
+    STARTING = "starting"
+    STOPPING = "stopping"
+
+
+class ProcessorStatus(str, Enum):
+    """Processor operational status."""
+
+    RUNNING = "running"
+    PAUSED = "paused"
+    STOPPED = "stopped"
+    ERROR = "error"
+
+
+class ConfigScope(str, Enum):
+    """Configuration scope levels."""
+
+    GLOBAL = "global"
+    ADAPTER = "adapter"
+    PROCESSOR = "processor"
+    SERVICE = "service"
+
+
+class ConfigValidationLevel(str, Enum):
+    """Configuration validation levels."""
+
+    SYNTAX = "syntax"
+    SCHEMA = "schema"
+    SEMANTIC = "semantic"
+    FULL = "full"
+
+
+class ProcessorQueueStatus(BaseModel):
+    """Status of a processor queue."""
+
+    processor_name: str = Field(..., description="Processor name")
+    queue_size: int = Field(..., description="Current queue size")
+    max_size: int = Field(..., description="Maximum queue size")
+    processing_rate: float = Field(..., description="Messages per second")
+    average_latency_ms: float = Field(..., description="Average processing latency")
+    oldest_message_age_seconds: Optional[float] = Field(None, description="Age of oldest message")
+
+
+class AdapterInfo(BaseModel):
+    """Information about an adapter."""
+
+    adapter_id: str = Field(..., description="Adapter identifier")
+    adapter_type: str = Field(..., description="Type of adapter")
+    status: AdapterStatus = Field(..., description="Current status")
+    started_at: Optional[datetime] = Field(None, description="Start time")
+    messages_processed: int = Field(0, description="Total messages processed")
+    error_count: int = Field(0, description="Total errors")
+    last_error: Optional[str] = Field(None, description="Last error message")
+    tools: Optional[List[ToolInfo]] = Field(None, description="Tools provided by adapter")
+
+
+class AdapterOperationResult(BaseModel):
+    """Result of an adapter operation."""
+
+    success: bool = Field(..., description="Whether operation succeeded")
+    adapter_id: str = Field(..., description="Adapter identifier")
+    adapter_type: str = Field(..., description="Type of adapter")
+    operation: str = Field(..., description="Operation performed")
+    error: Optional[str] = Field(None, description="Error message if failed")
+
+
+class ConfigBackup(BaseModel):
+    """Configuration backup information."""
+
+    backup_id: str = Field(..., description="Backup identifier")
+    created_at: datetime = Field(..., description="When backup was created")
+    config_version: str = Field(..., description="Config version backed up")
+    size_bytes: int = Field(..., description="Backup size")
+    path: str = Field(..., description="Backup file path")
+    description: Optional[str] = Field(None, description="Backup description")
+
+
+class ServiceRegistryInfo(BaseModel):
+    """Service registry information."""
+
+    total_services: int = Field(..., description="Total registered services")
+    services_by_type: Dict[str, int] = Field(..., description="Count by service type")
+    handlers: Dict[str, List[str]] = Field(..., description="Handlers and their services")
+    healthy_services: int = Field(..., description="Number of healthy services")
+    circuit_breaker_states: Dict[str, str] = Field(..., description="Circuit breaker states")
+
+
+class CircuitBreakerResetResult(BaseModel):
+    """Result of circuit breaker reset operation."""
+
+    success: bool = Field(..., description="Whether reset succeeded")
+    reset_count: int = Field(..., description="Number of breakers reset")
+    reset_services: List[str] = Field(..., description="Services that were reset")
+    errors: List[str] = Field(default_factory=list, description="Any errors encountered")
+
+
+class ServiceHealthStatus(BaseModel):
+    """Health status of services."""
+
+    overall_health: str = Field(..., description="Overall health: healthy, degraded, unhealthy")
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    healthy_services: int = Field(..., description="Number of healthy services")
+    unhealthy_services: int = Field(..., description="Number of unhealthy services")
+    service_details: Dict[str, ConfigDict] = Field(..., description="Per-service health details")
+    recommendations: List[str] = Field(default_factory=list, description="Health recommendations")
+
+
+class ServiceSelectionExplanation(BaseModel):
+    """Explanation of service selection logic."""
+
+    overview: str = Field(..., description="Overview of selection logic")
+    priority_groups: Dict[int, str] = Field(..., description="Priority group explanations")
+    priorities: Optional[Dict[str, ConfigDict]] = Field(
+        default_factory=lambda: {}, description="Priority level details"
+    )
+    selection_strategies: Dict[str, str] = Field(..., description="Strategy explanations")
+    selection_flow: Optional[List[str]] = Field(default_factory=lambda: [], description="Selection flow steps")
+    circuit_breaker_info: Optional[ConfigDict] = Field(
+        default_factory=lambda: {}, description="Circuit breaker information"
+    )
+    examples: List[ConfigDict] = Field(..., description="Example scenarios")
+    configuration_tips: List[str] = Field(..., description="Configuration recommendations")
+
+
+class RuntimeEvent(BaseModel):
+    """Runtime event notification."""
+
+    event_type: str = Field(..., description="Type of event")
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    source: str = Field(..., description="Event source")
+    details: ConfigDict = Field(..., description="Event details")
+    severity: str = Field("info", description="Event severity")
+
+
+class ConfigReloadResult(BaseModel):
+    """Result of configuration reload."""
+
+    success: bool = Field(..., description="Whether reload succeeded")
+    config_version: str = Field(..., description="New config version")
+    changes_applied: int = Field(..., description="Number of changes applied")
+    warnings: List[str] = Field(default_factory=list, description="Configuration warnings")
+    error: Optional[str] = Field(None, description="Error if reload failed")
+
+
+class ProcessorControlResponse(BaseModel):
+    """Response from processor control operations."""
+
+    success: bool = Field(..., description="Whether operation succeeded")
+    processor_name: str = Field(..., description="Processor name")
+    operation: str = Field(..., description="Operation performed")
+    new_status: ProcessorStatus = Field(..., description="New processor status")
+    error: Optional[str] = Field(None, description="Error message if failed")
+
+    # H3ERE step data for single-step operations
+    step_point: Optional[str] = Field(None, description="H3ERE step point executed")
+    step_results: Optional[List[StepResultData]] = Field(None, description="Step results organized by round and task")
+    thoughts_processed: Optional[int] = Field(None, description="Number of thoughts processed")
+    processing_time_ms: Optional[float] = Field(None, description="Processing time in milliseconds")
+    pipeline_state: Optional[PipelineState] = Field(None, description="Current pipeline state")
+    current_round: Optional[int] = Field(None, description="Current processing round")
+    pipeline_empty: Optional[bool] = Field(None, description="Whether pipeline is empty")
+
+
+class AdapterOperationResponse(BaseModel):
+    """Response from adapter operations."""
+
+    success: bool = Field(..., description="Whether operation succeeded")
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    adapter_id: str = Field(..., description="Adapter identifier")
+    adapter_type: str = Field(..., description="Adapter type")
+    status: AdapterStatus = Field(..., description="Current adapter status")
+    error: Optional[str] = Field(None, description="Error message if failed")
+
+
+class RuntimeStatusResponse(BaseModel):
+    """Overall runtime status response."""
+
+    is_running: bool = Field(..., description="Whether runtime is active")
+    uptime_seconds: float = Field(..., description="Runtime uptime")
+    processor_count: int = Field(..., description="Number of processors")
+    adapter_count: int = Field(..., description="Number of adapters")
+    total_messages_processed: int = Field(..., description="Total messages processed")
+    current_load: float = Field(..., description="Current system load")
+    processor_status: ProcessorStatus = Field(
+        ProcessorStatus.RUNNING, description="Current processor operational status"
+    )
+    cognitive_state: Optional[str] = Field(None, description="Current cognitive state (AgentState)")
+    queue_depth: int = Field(0, description="Number of items in processing queue")
+
+
+class RuntimeStateSnapshot(BaseModel):
+    """Complete runtime state snapshot."""
+
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    runtime_status: RuntimeStatusResponse = Field(..., description="Runtime status")
+    processors: List[ProcessorQueueStatus] = Field(..., description="Processor statuses")
+    adapters: List[AdapterInfo] = Field(..., description="Adapter information")
+    config_version: str = Field(..., description="Current config version")
+    health_summary: ServiceHealthStatus = Field(..., description="Service health summary")
+
+
+class ConfigSnapshot(BaseModel):
+    """Configuration snapshot for runtime control."""
+
+    configs: ConfigDict = Field(..., description="Configuration key-value pairs")
+    version: str = Field(..., description="Configuration version")
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    sensitive_keys: List[str] = Field(default_factory=list, description="Keys containing sensitive data")
+    metadata: JSONDict = Field(default_factory=dict, description="Additional metadata")
+
+
+class ConfigOperationResponse(BaseModel):
+    """Response from configuration operations."""
+
+    success: bool = Field(..., description="Whether operation succeeded")
+    operation: str = Field(..., description="Operation performed")
+    config_path: Optional[str] = Field(None, description="Configuration path")
+    details: ConfigDict = Field(default_factory=dict, description="Operation details")
+    error: Optional[str] = Field(None, description="Error message if failed")
+
+
+class ConfigValidationResponse(BaseModel):
+    """Configuration validation response."""
+
+    valid: bool = Field(..., description="Whether config is valid")
+    validation_level: ConfigValidationLevel = Field(..., description="Level of validation")
+    errors: List[str] = Field(default_factory=list, description="Validation errors")
+    warnings: List[str] = Field(default_factory=list, description="Validation warnings")
+    suggestions: List[str] = Field(default_factory=list, description="Improvement suggestions")
+
+
+class ConfigBackupResponse(BaseModel):
+    """Configuration backup response."""
+
+    success: bool = Field(..., description="Whether backup succeeded")
+    backup_id: str = Field(..., description="Backup identifier")
+    backup_path: str = Field(..., description="Where backup was saved")
+    size_bytes: int = Field(..., description="Backup size")
+    error: Optional[str] = Field(None, description="Error message if failed")