Fix the failing test from its log. Public repository OmniNode-ai/omnibase_core, snapshot fae8470aaa37622390c9e7f647662d9b9649f40c.
Return only a unified diff for src/omnibase_core/models/delegation/model_invocation_command.py; do not change any test, contract, configuration, dependency or other file. The regression was seeded by restoring this product source file to the parent of a recent fix commit. Do not assume access to a workspace. Preserve existing behavior and strong UUID types.
The unchanged test command is: pytest tests/unit/models/delegation/test_delegation_models.py -q --tb=short
Failing test log:
[1m============================= test session starts ==============================[0m
platform darwin -- Python 3.13.12, pytest-9.0.3, pluggy-1.6.0
rootdir: fixture-root
configfile: pytest.ini
plugins: hypothesis-6.151.6, mock-3.15.1, locust-2.43.3, xdist-3.8.0, split-0.11.0, timeout-2.4.0, cov-6.3.0, anyio-4.14.2, pytest_httpserver-1.1.5, asyncio-1.3.0
asyncio: mode=Mode.STRICT, debug=False, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function
collected 22 items

tests/unit/models/delegation/test_delegation_models.py [32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[31mF[0m[32m.[0m[32m.[0m[32m.[0m[31m [ 77%]
[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[32m.[0m[31m                                                                    [100%][0m

=================================== FAILURES ===================================
[31m[1m_____________ TestModelInvocationCommand.test_unknown_key_rejected _____________[0m
[1m[31mtests/unit/models/delegation/test_delegation_models.py[0m:130: in test_unknown_key_rejected
    [0m[94mwith[39;49;00m pytest.raises(ValidationError, match=[33m"[39;49;00m[33munexpected_field[39;49;00m[33m"[39;49;00m):[90m[39;49;00m
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^[90m[39;49;00m
[1m[31mE   Failed: DID NOT RAISE <class 'pydantic_core._pydantic_core.ValidationError'>[0m
[36m[1m=========================== short test summary info ============================[0m
[31mFAILED[0m tests/unit/models/delegation/test_delegation_models.py::[1mTestModelInvocationCommand::test_unknown_key_rejected[0m - Failed: DID NOT RAISE <class 'pydantic_core._pydantic_core.ValidationError'>
[31m========================= [31m[1m1 failed[0m, [32m21 passed[0m[31m in 0.41s[0m[31m =========================[0m


Current faulty source src/omnibase_core/models/delegation/model_invocation_command.py:
```python
# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
# SPDX-License-Identifier: MIT
"""ModelInvocationCommand: typed command emitted by the routing reducer (OMN-9637)."""

from __future__ import annotations

from uuid import UUID

from pydantic import BaseModel, ConfigDict, model_validator

from omnibase_core.enums.enum_agent_protocol import EnumAgentProtocol
from omnibase_core.enums.enum_invocation_kind import EnumInvocationKind
from omnibase_core.models.common.model_schema_value import ModelSchemaValue


class ModelInvocationCommand(BaseModel):
    """Typed invocation command emitted by the delegation routing reducer.

    Carries all routing resolution outputs needed for the orchestrator FSM and
    the remote-agent invoke effect to act on the delegation request.
    """

    model_config = ConfigDict(frozen=True)

    task_id: UUID
    correlation_id: UUID
    invocation_kind: EnumInvocationKind
    agent_protocol: EnumAgentProtocol | None = None
    model_backend: str | None = None
    target_ref: str
    payload: dict[str, ModelSchemaValue] = {}

    @model_validator(mode="after")
    def _validate_kind_invariants(self) -> ModelInvocationCommand:
        if (
            self.invocation_kind is EnumInvocationKind.AGENT
            and self.agent_protocol is None
        ):
            msg = "agent_protocol is required when invocation_kind is AGENT"
            raise ValueError(msg)
        if (
            self.invocation_kind is EnumInvocationKind.AGENT
            and self.model_backend is not None
        ):
            msg = "model_backend must be None when invocation_kind is AGENT"
            raise ValueError(msg)
        if (
            self.invocation_kind is EnumInvocationKind.MODEL
            and self.model_backend is None
        ):
            msg = "model_backend is required when invocation_kind is MODEL"
            raise ValueError(msg)
        if (
            self.invocation_kind is EnumInvocationKind.MODEL
            and self.agent_protocol is not None
        ):
            msg = "agent_protocol must be None when invocation_kind is MODEL"
            raise ValueError(msg)
        return self


__all__ = ["ModelInvocationCommand"]

```
Unchanged test source:
```python
# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
# SPDX-License-Identifier: MIT
"""Unit tests for omnibase_core.models.delegation (OMN-9637)."""

from __future__ import annotations

import uuid
from datetime import UTC, datetime

import pytest
from pydantic import ValidationError

from omnibase_core.enums.enum_agent_capability import EnumAgentCapability
from omnibase_core.enums.enum_agent_protocol import EnumAgentProtocol
from omnibase_core.enums.enum_agent_task_lifecycle_type import (
    EnumAgentTaskLifecycleType,
)
from omnibase_core.enums.enum_invocation_kind import EnumInvocationKind
from omnibase_core.models.common.model_schema_value import ModelSchemaValue
from omnibase_core.models.delegation.model_a2a_task_request import ModelA2ATaskRequest
from omnibase_core.models.delegation.model_a2a_task_response import ModelA2ATaskResponse
from omnibase_core.models.delegation.model_agent_task_lifecycle_event import (
    ModelAgentTaskLifecycleEvent,
)
from omnibase_core.models.delegation.model_invocation_command import (
    ModelInvocationCommand,
)
from omnibase_core.models.delegation.model_remote_task_state import ModelRemoteTaskState
from omnibase_core.models.delegation.model_routing_rule import ModelRoutingRule
from omnibase_core.models.delegation.model_target_agent import ModelTargetAgent

_NOW = datetime(2026, 4, 25, 12, 0, 0, tzinfo=UTC)
_TASK_ID = uuid.UUID("aaaaaaaa-0000-0000-0000-000000000001")
_CORR_ID = uuid.UUID("bbbbbbbb-0000-0000-0000-000000000002")


@pytest.mark.unit
class TestModelInvocationCommand:
    def test_minimal_valid(self) -> None:
        cmd = ModelInvocationCommand(
            task_id=_TASK_ID,
            correlation_id=_CORR_ID,
            invocation_kind=EnumInvocationKind.AGENT,
            agent_protocol=EnumAgentProtocol.A2A,
            target_ref="adk-scout",
        )
        assert cmd.task_id == _TASK_ID
        assert cmd.invocation_kind is EnumInvocationKind.AGENT
        assert cmd.agent_protocol is EnumAgentProtocol.A2A
        assert cmd.payload == {}

    def test_with_protocol_and_payload(self) -> None:
        cmd = ModelInvocationCommand(
            task_id=_TASK_ID,
            correlation_id=_CORR_ID,
            invocation_kind=EnumInvocationKind.AGENT,
            agent_protocol=EnumAgentProtocol.A2A,
            target_ref="adk-scout",
            payload={"x": ModelSchemaValue.from_value("hello")},
        )
        assert cmd.agent_protocol is EnumAgentProtocol.A2A
        assert "x" in cmd.payload

    def test_frozen(self) -> None:
        cmd = ModelInvocationCommand(
            task_id=_TASK_ID,
            correlation_id=_CORR_ID,
            invocation_kind=EnumInvocationKind.MODEL,
            model_backend="qwen3",
            target_ref="qwen3",
        )
        with pytest.raises(Exception):
            cmd.target_ref = "changed"  # type: ignore[misc]

    def test_agent_without_protocol_raises(self) -> None:
        with pytest.raises(ValidationError, match="agent_protocol is required"):
            ModelInvocationCommand(
                task_id=_TASK_ID,
                correlation_id=_CORR_ID,
                invocation_kind=EnumInvocationKind.AGENT,
                target_ref="adk-scout",
            )

    def test_model_without_backend_raises(self) -> None:
        with pytest.raises(ValidationError, match="model_backend is required"):
            ModelInvocationCommand(
                task_id=_TASK_ID,
                correlation_id=_CORR_ID,
                invocation_kind=EnumInvocationKind.MODEL,
                target_ref="qwen3",
            )

    def test_agent_with_model_backend_raises(self) -> None:
        with pytest.raises(
            ValidationError,
            match="model_backend must be None when invocation_kind is AGENT",
        ):
            ModelInvocationCommand(
                task_id=_TASK_ID,
                correlation_id=_CORR_ID,
                invocation_kind=EnumInvocationKind.AGENT,
                agent_protocol=EnumAgentProtocol.A2A,
                model_backend="qwen3",
                target_ref="adk-scout",
            )

    def test_model_with_agent_protocol_raises(self) -> None:
        with pytest.raises(
            ValidationError,
            match="agent_protocol must be None when invocation_kind is MODEL",
        ):
            ModelInvocationCommand(
                task_id=_TASK_ID,
                correlation_id=_CORR_ID,
                invocation_kind=EnumInvocationKind.MODEL,
                model_backend="qwen3",
                agent_protocol=EnumAgentProtocol.A2A,
                target_ref="qwen3",
            )

    def test_unknown_key_rejected(self) -> None:
        payload = {
            "task_id": _TASK_ID,
            "correlation_id": _CORR_ID,
            "invocation_kind": EnumInvocationKind.AGENT,
            "agent_protocol": EnumAgentProtocol.A2A,
            "target_ref": "adk-scout",
            "unexpected_field": "x",
        }
        with pytest.raises(ValidationError, match="unexpected_field"):
            ModelInvocationCommand.model_validate(payload)


@pytest.mark.unit
class TestModelAgentTaskLifecycleEvent:
    def test_minimal_valid(self) -> None:
        evt = ModelAgentTaskLifecycleEvent(
            task_id=_TASK_ID,
            correlation_id=_CORR_ID,
            lifecycle_type=EnumAgentTaskLifecycleType.SUBMITTED,
            occurred_at=_NOW,
        )
        assert evt.lifecycle_type is EnumAgentTaskLifecycleType.SUBMITTED
        assert evt.artifact is None
        assert evt.error is None

    def test_with_artifact_and_error(self) -> None:
        evt = ModelAgentTaskLifecycleEvent(
            task_id=_TASK_ID,
            correlation_id=_CORR_ID,
            lifecycle_type=EnumAgentTaskLifecycleType.FAILED,
            occurred_at=_NOW,
            artifact={"k": ModelSchemaValue.from_value("v")},
            error="timeout",
        )
        assert evt.error == "timeout"
        assert evt.artifact is not None and "k" in evt.artifact

    def test_unknown_key_rejected(self) -> None:
        payload = {
            "task_id": _TASK_ID,
            "correlation_id": _CORR_ID,
            "lifecycle_type": EnumAgentTaskLifecycleType.SUBMITTED,
            "occurred_at": _NOW,
            "unexpected_field": "x",
        }
        with pytest.raises(ValidationError, match="unexpected_field"):
            ModelAgentTaskLifecycleEvent.model_validate(payload)


@pytest.mark.unit
class TestModelRoutingRule:
    def test_valid_agent_rule(self) -> None:
        rule = ModelRoutingRule(
            capability=EnumAgentCapability.TECH_DEBT_TRIAGE,
            invocation_kind=EnumInvocationKind.AGENT,
            agent_protocol=EnumAgentProtocol.A2A,
            target_ref="adk-scout",
        )
        assert rule.capability is EnumAgentCapability.TECH_DEBT_TRIAGE
        assert rule.fallbacks == ()

    def test_missing_required_fields_raises(self) -> None:
        with pytest.raises(ValidationError):
            ModelRoutingRule.model_validate({"invocation_kind": "agent"})

    def test_agent_rule_without_protocol_raises(self) -> None:
        with pytest.raises(ValidationError, match="agent_protocol is required"):
            ModelRoutingRule(
                capability=EnumAgentCapability.TECH_DEBT_TRIAGE,
                invocation_kind=EnumInvocationKind.AGENT,
                target_ref="adk-scout",
            )


@pytest.mark.unit
class TestModelTargetAgent:
    def test_valid(self) -> None:
        agent = ModelTargetAgent(
            target_ref="adk-scout",
            base_url="http://localhost:9080",
            protocol=EnumAgentProtocol.A2A,
        )
        assert agent.protocol is EnumAgentProtocol.A2A


@pytest.mark.unit
class TestModelA2ATaskRequest:
    def test_valid(self) -> None:
        req = ModelA2ATaskRequest(
            skill_ref="scout",
            input={"prompt": ModelSchemaValue.from_value("triage these")},
            correlation_id=_CORR_ID,
        )
        assert req.skill_ref == "scout"
        assert "prompt" in req.input


@pytest.mark.unit
class TestModelA2ATaskResponse:
    def test_minimal(self) -> None:
        resp = ModelA2ATaskResponse(
            remote_task_handle="t-123",
            status=EnumAgentTaskLifecycleType.PROGRESS,
        )
        assert resp.artifacts == []
        assert resp.error is None

    def test_with_artifacts(self) -> None:
        resp = ModelA2ATaskResponse(
            remote_task_handle="t-123",
            status=EnumAgentTaskLifecycleType.COMPLETED,
            artifacts=[{"result": ModelSchemaValue.from_value("done")}],
        )
        assert len(resp.artifacts) == 1

    def test_invalid_status_raises(self) -> None:
        with pytest.raises(ValidationError):
            ModelA2ATaskResponse(
                remote_task_handle="t-123", status="not_a_valid_status"
            )


@pytest.mark.unit
class TestModelRemoteTaskState:
    def test_valid(self) -> None:
        state = ModelRemoteTaskState(
            task_id=_TASK_ID,
            invocation_kind=EnumInvocationKind.AGENT,
            protocol=EnumAgentProtocol.A2A,
            target_ref="adk-scout",
            correlation_id=_CORR_ID,
            status=EnumAgentTaskLifecycleType.SUBMITTED,
            submitted_at=_NOW,
            updated_at=_NOW,
        )
        assert state.status is EnumAgentTaskLifecycleType.SUBMITTED
        assert state.completed_at is None

    def test_agent_without_protocol_raises(self) -> None:
        with pytest.raises(ValidationError, match="protocol is required"):
            ModelRemoteTaskState(
                task_id=_TASK_ID,
                invocation_kind=EnumInvocationKind.AGENT,
                protocol=None,
                target_ref="adk-scout",
                correlation_id=_CORR_ID,
                status=EnumAgentTaskLifecycleType.SUBMITTED,
                submitted_at=_NOW,
                updated_at=_NOW,
            )

    def test_model_validate_from_dict(self) -> None:
        data = {
            "task_id": str(_TASK_ID),
            "invocation_kind": "agent",
            "protocol": "A2A",
            "target_ref": "adk-scout",
            "correlation_id": str(_CORR_ID),
            "status": "SUBMITTED",
            "submitted_at": _NOW,
            "updated_at": _NOW,
        }
        state = ModelRemoteTaskState.model_validate(data)
        assert state.invocation_kind is EnumInvocationKind.AGENT
        assert state.protocol is EnumAgentProtocol.A2A

```
