feat(OMN-12126): graduate delegation wire DTOs from omnibase_compat to omnibase_core

scripts/validation/validate-single-class-per-file.py

@@ -186,6 +186,12 @@ def should_exclude_file(filepath: Path) -> bool:
         "model_database_secure_config.py",  # Database config with nested models
         "model_service_registry_config.py",  # Service config models
         "model_epic_state.py",  # 3 tightly-coupled epic state models; split tracked in OMN-4401
+        # Delegation wire DTO files (graduated from omnibase_compat, OMN-12126).
+        # These files group related intent/config DTOs by domain. Split tracked separately.
+        "model_orchestrator_intents.py",  # 6 related orchestrator intent DTOs
+        "model_routing_config.py",  # ModelTierModel + ModelRoutingTier + ModelDelegationConfig (hierarchy)
+        "model_quality_gate.py",  # ModelQualityGateInput + ModelQualityGateResult (paired gate DTOs)
+        "model_bifrost_delegation_config.py",  # 7 tightly-coupled Bifrost gateway config DTOs
     }
 
     # Exclude validator files with small helper classes

src/omnibase_core/enums/enum_budget_action.py

@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
+# SPDX-License-Identifier: MIT
+
+"""Budget policy outcome enum for the delegation compliance loop."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class EnumBudgetAction(StrEnum):
+    """Budget policy outcome used by the compliance loop."""
+
+    CONTINUE = "CONTINUE"
+    WARN = "WARN"
+    THROTTLE = "THROTTLE"
+    ABORT = "ABORT"
+
+
+__all__: list[str] = ["EnumBudgetAction"]

src/omnibase_core/models/delegation/wire/__init__.py

@@ -0,0 +1,86 @@
+# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
+# SPDX-License-Identifier: MIT
+
+"""Canonical delegation wire DTOs (graduated from omnibase_compat, OMN-12126)."""
+
+from omnibase_core.models.delegation.wire.model_bifrost_delegation_config import (
+    ModelBifrostDelegationConfig,
+    ModelDelegationBackendConfig,
+    ModelDelegationCircuitBreakerConfig,
+    ModelDelegationFailoverConfig,
+    ModelDelegationFallbackPolicy,
+    ModelDelegationRoutingRule,
+    ModelDelegationShadowConfig,
+)
+from omnibase_core.models.delegation.wire.model_budget import (
+    EnumBudgetAction,
+    ModelBudgetLimits,
+)
+from omnibase_core.models.delegation.wire.model_delegation_result import (
+    ModelDelegationResult,
+)
+from omnibase_core.models.delegation.wire.model_delegation_wire_envelope import (
+    ModelDelegationEventEnvelope,
+)
+from omnibase_core.models.delegation.wire.model_delegation_wire_request import (
+    MAX_WORDS_PER_SENTENCE_RE,
+    SUPPORTED_ACCEPTANCE_CRITERIA,
+    EnumQualityContractMode,
+    ModelDelegationRequest,
+    validate_acceptance_criteria,
+)
+from omnibase_core.models.delegation.wire.model_orchestrator_intents import (
+    ModelBaselineIntent,
+    ModelComplianceLoopResult,
+    ModelInferenceIntent,
+    ModelInferenceResponseData,
+    ModelQualityGateIntent,
+    ModelRoutingIntent,
+)
+from omnibase_core.models.delegation.wire.model_quality_gate import (
+    EnumQualityGateCategory,
+    ModelQualityGateInput,
+    ModelQualityGateResult,
+)
+from omnibase_core.models.delegation.wire.model_routing_config import (
+    ModelDelegationConfig,
+    ModelRoutingTier,
+    ModelTierModel,
+)
+from omnibase_core.models.delegation.wire.model_task_delegated_event import (
+    TASK_DELEGATED_TOPIC_V1,
+    ModelTaskDelegatedEvent,
+)
+
+__all__: list[str] = [
+    "MAX_WORDS_PER_SENTENCE_RE",
+    "SUPPORTED_ACCEPTANCE_CRITERIA",
+    "TASK_DELEGATED_TOPIC_V1",
+    "EnumBudgetAction",
+    "EnumQualityContractMode",
+    "EnumQualityGateCategory",
+    "ModelBaselineIntent",
+    "ModelBifrostDelegationConfig",
+    "ModelBudgetLimits",
+    "ModelComplianceLoopResult",
+    "ModelDelegationBackendConfig",
+    "ModelDelegationCircuitBreakerConfig",
+    "ModelDelegationConfig",
+    "ModelDelegationEventEnvelope",
+    "ModelDelegationFailoverConfig",
+    "ModelDelegationFallbackPolicy",
+    "ModelDelegationRequest",
+    "ModelDelegationResult",
+    "ModelDelegationRoutingRule",
+    "ModelDelegationShadowConfig",
+    "ModelInferenceIntent",
+    "ModelInferenceResponseData",
+    "ModelQualityGateInput",
+    "ModelQualityGateIntent",
+    "ModelQualityGateResult",
+    "ModelRoutingIntent",
+    "ModelRoutingTier",
+    "ModelTaskDelegatedEvent",
+    "ModelTierModel",
+    "validate_acceptance_criteria",
+]

src/omnibase_core/models/delegation/wire/model_bifrost_delegation_config.py

@@ -0,0 +1,259 @@
+# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
+# SPDX-License-Identifier: MIT
+
+"""Bifrost delegation config wire DTOs."""
+
+from __future__ import annotations
+
+from typing import Literal
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ModelDelegationShadowConfig(BaseModel):
+    """Shadow routing comparison settings."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid", from_attributes=True)
+
+    enabled: bool = Field(default=False, description="Whether shadow mode is active.")
+    policy_version: str = Field(
+        default="unknown",
+        max_length=128,
+        description="Human-readable version of the loaded shadow policy checkpoint.",
+    )
+    log_sample_rate: float = Field(
+        default=1.0,
+        ge=0.0,
+        le=1.0,
+        description="Fraction of requests to log shadow decisions for.",
+    )
+    comparison_logging_enabled: bool = Field(
+        default=True,
+        description="Whether to emit comparison events for shadow decisions.",
+    )
+    max_shadow_latency_ms: float = Field(
+        default=5.0,
+        ge=0.1,
+        le=100.0,
+        description="Maximum allowed latency for shadow policy evaluation (ms).",
+    )
+    shadow_label: Literal["SHADOW"] = Field(
+        default="SHADOW",
+        description="Label applied to all shadow comparison events.",
+    )
+
+
+class ModelDelegationFallbackPolicy(BaseModel):
+    """Per-rule fallback behavior when backend attempts fail."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid", from_attributes=True)
+
+    action: Literal["escalate_to_next_tier", "return_error"] = Field(
+        ...,
+        description="Action on backend failure: 'escalate_to_next_tier' or 'return_error'.",
+    )
+    max_retries: int = Field(
+        default=1,
+        ge=0,
+        le=10,
+        description="Maximum retry attempts across backends in this rule.",
+    )
+    on_exhaust: Literal["return_error", "escalate_to_next_tier"] = Field(
+        default="return_error",
+        description="Behavior when all retries are exhausted.",
+    )
+
+
+class ModelDelegationRoutingRule(BaseModel):
+    """Routing rule from task class constraints to ordered backend IDs."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid", from_attributes=True)
+
+    rule_id: UUID = Field(
+        ..., description="Stable UUID for audit logging and provenance."
+    )
+    priority: int = Field(
+        default=100,
+        ge=0,
+        description="Evaluation order - lower values evaluated first.",
+    )
+    task_class: str = Field(..., description="Task class this rule targets.")
+    # string-version-ok: external contract version string from YAML config, not a ModelSemVer object
+    task_class_contract_version: str = Field(
+        ...,
+        description="Version of the task class contract this rule was authored against.",
+    )
+    # string-version-ok: external policy version string from YAML config, not a ModelSemVer object
+    backend_policy_version: str = Field(
+        ...,
+        description="Version of the backend policy applied by this rule.",
+    )
+    match_operation_types: tuple[str, ...] = Field(
+        default_factory=tuple,
+        description="Operation types this rule matches (empty = any).",
+    )
+    match_capabilities: tuple[str, ...] = Field(
+        default_factory=tuple,
+        description="Capabilities the request must declare (empty = any).",
+    )
+    latency_sla_ms: int | None = Field(
+        default=None,
+        ge=1,
+        description="SLA latency constraint.",
+    )
+    cost_ceiling_usd_per_1k_tokens: float | None = Field(
+        default=None,
+        ge=0.0,
+        description="Maximum allowed cost per 1K tokens for this rule's backends.",
+    )
+    backend_ids: tuple[str, ...] = Field(
+        ...,
+        min_length=1,
+        description="Ordered backend IDs to try when this rule matches.",
+    )
+    fallback_policy: ModelDelegationFallbackPolicy = Field(
+        ...,
+        description="Failover behavior when backends are exhausted.",
+    )
+    shadow_policy_id: UUID = Field(
+        ..., description="Shadow policy UUID for A/B evaluation."
+    )
+
+
+class ModelDelegationBackendConfig(BaseModel):
+    """Backend definition for the Bifrost delegation gateway."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid", from_attributes=True)
+
+    # string-id-ok: backend_id is a human-readable slug (e.g. "local_qwen3"), not a UUID
+    backend_id: str = Field(
+        ..., min_length=1, description="Stable human-readable slug."
+    )
+    base_url_env: str | None = Field(
+        default=None,
+        description="Env var name holding the backend base URL (local backends).",
+    )
+    endpoint_url: str | None = Field(
+        default=None,
+        description=(
+            "Endpoint URL populated by deploy-time overlay. Null for local "
+            "backends until overlay is applied."
+        ),
+    )
+    model_name: str | None = Field(
+        default=None,
+        description=(
+            "Model identifier sent in outbound requests. Null for local "
+            "backends resolved at deploy time."
+        ),
+    )
+    api_key_env: str | None = Field(
+        default=None,
+        description="Optional environment variable name holding the backend API key.",
+    )
+    extra_headers: dict[str, str] | None = Field(
+        default=None,
+        description="Optional static HTTP headers required by the backend provider.",
+    )
+    tier: Literal["local", "frontier_api"] = Field(
+        ..., description="Routing tier: 'local' or 'frontier_api'."
+    )
+    timeout_ms: int = Field(
+        default=30000,
+        ge=100,
+        le=600000,
+        description="Per-backend HTTP timeout in milliseconds.",
+    )
+    capabilities: tuple[str, ...] = Field(
+        default_factory=tuple,
+        description="Capabilities this backend supports.",
+    )
+
+
+class ModelDelegationCircuitBreakerConfig(BaseModel):
+    """Circuit breaker settings applying to all Bifrost backends."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid", from_attributes=True)
+
+    failure_threshold: int = Field(
+        default=5,
+        ge=1,
+        le=100,
+        description="Consecutive failures that open the circuit.",
+    )
+    window_seconds: int = Field(
+        default=30,
+        ge=1,
+        le=3600,
+        description="Cooldown duration after circuit opens, in seconds.",
+    )
+
+
+class ModelDelegationFailoverConfig(BaseModel):
+    """Gateway-level failover settings."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid", from_attributes=True)
+
+    max_attempts: int = Field(
+        default=3,
+        ge=1,
+        le=10,
+        description="Maximum backend attempts per request.",
+    )
+    backoff_base_ms: int = Field(
+        default=500,
+        ge=0,
+        le=10000,
+        description="Base exponential backoff delay in milliseconds.",
+    )
+
+
+class ModelBifrostDelegationConfig(BaseModel):
+    """Bifrost delegation gateway configuration."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid", from_attributes=True)
+
+    # string-version-ok: config_version is a semver string from YAML, not a ModelSemVer object
+    config_version: str = Field(..., description="Semver config version.")
+    # string-version-ok: schema_version is a format identifier string, not a ModelSemVer object
+    schema_version: str = Field(
+        ..., description="Schema identifier for this config format."
+    )
+    backends: tuple[ModelDelegationBackendConfig, ...] = Field(
+        ...,
+        min_length=1,
+        description="Backend definitions with deployed endpoint URLs.",
+    )
+    routing_rules: tuple[ModelDelegationRoutingRule, ...] = Field(
+        ...,
+        min_length=1,
+        description="Routing rules evaluated in ascending priority order.",
+    )
+    default_backends: tuple[str, ...] = Field(
+        default_factory=tuple,
+        description="Fallback backend IDs when no routing rule matches.",
+    )
+    circuit_breaker: ModelDelegationCircuitBreakerConfig = Field(
+        default_factory=ModelDelegationCircuitBreakerConfig,
+        description="Circuit breaker settings applying to all backends.",
+    )
+    failover: ModelDelegationFailoverConfig = Field(
+        default_factory=ModelDelegationFailoverConfig,
+        description="Gateway-level failover settings.",
+    )
+    shadow_mode: ModelDelegationShadowConfig = Field(
+        default_factory=ModelDelegationShadowConfig,
+        description="Shadow mode configuration for delegation A/B testing.",
+    )
+
+
+__all__: list[str] = [
+    "ModelBifrostDelegationConfig",
+    "ModelDelegationBackendConfig",
+    "ModelDelegationCircuitBreakerConfig",
+    "ModelDelegationFailoverConfig",
+    "ModelDelegationFallbackPolicy",
+    "ModelDelegationRoutingRule",
+    "ModelDelegationShadowConfig",
+]