Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /dislovelhl_enhanced-agent-bus /result_finalizer.py
| from __future__ import annotations | |
| import time | |
| from collections.abc import Awaitable, Callable | |
| from typing import TYPE_CHECKING, Any, Protocol, TypeAlias | |
| if TYPE_CHECKING: | |
| from enhanced_agent_bus._compat.types import JSONDict | |
| else: | |
| JSONDict: TypeAlias = dict[str, Any] | |
| from enhanced_agent_bus.data_flywheel.ingest import build_decision_event | |
| from enhanced_agent_bus.observability.structured_logging import get_logger | |
| from .message_processor_components import build_dlq_entry | |
| from .models import AgentMessage, Priority, get_enum_value | |
| from .validators import ValidationResult | |
| logger = get_logger(__name__) | |
| class BackgroundTaskScheduler(Protocol): | |
| def __call__(self, coroutine: Awaitable[object], background_tasks: set[object]) -> object: ... | |
| class ResultFinalizer: | |
| """Shared result sink orchestration for MessageProcessor. | |
| Keeps success/failure side effects together so early rejections and strategy failures can use | |
| the same audit, persistence, metering, and DLQ behavior. | |
| """ | |
| async def handle_successful_processing( | |
| self, | |
| *, | |
| msg: AgentMessage, | |
| result: ValidationResult, | |
| cache_key: str, | |
| latency_ms: float, | |
| validation_cache: Any, | |
| clone_validation_result: Callable[[ValidationResult], ValidationResult], | |
| processed_counter_increment: Callable[[], None], | |
| schedule_governance_audit_event: Callable[[AgentMessage, ValidationResult], None], | |
| persist_flywheel_decision_event: Callable[ | |
| [AgentMessage, ValidationResult], Awaitable[None] | |
| ], | |
| requires_independent_validation: Callable[[AgentMessage], bool], | |
| record_agent_workflow_event: Callable[..., None], | |
| metering_hooks: object | None, | |
| async_metering_callback: Callable[[AgentMessage, float], Awaitable[None]], | |
| schedule_background_task_fn: BackgroundTaskScheduler, | |
| background_tasks: set[object], | |
| ) -> None: | |
| if isinstance(result.metadata, dict): | |
| result.metadata.setdefault("latency_ms", latency_ms) | |
| result.metadata.setdefault( | |
| "flywheel_decision_event", | |
| build_decision_event(msg, result).model_dump(mode="json"), | |
| ) | |
| validation_cache.set(cache_key, clone_validation_result(result)) | |
| processed_counter_increment() | |
| schedule_governance_audit_event(msg, result) | |
| await persist_flywheel_decision_event(msg, result) | |
| if not requires_independent_validation(msg): | |
| record_agent_workflow_event( | |
| event_type="autonomous_action", | |
| msg=msg, | |
| reason="no_independent_validation_required", | |
| ) | |
| if metering_hooks: | |
| schedule_background_task_fn( | |
| async_metering_callback(msg, latency_ms), | |
| background_tasks, | |
| ) | |
| async def handle_failed_processing( | |
| self, | |
| *, | |
| msg: AgentMessage, | |
| result: ValidationResult, | |
| increment_failed_count: bool, | |
| failed_counter_increment: Callable[[], None], | |
| failure_stage: str, | |
| extract_rejection_reason: Callable[[ValidationResult], str], | |
| schedule_governance_audit_event: Callable[[AgentMessage, ValidationResult], None], | |
| persist_flywheel_decision_event: Callable[ | |
| [AgentMessage, ValidationResult], Awaitable[None] | |
| ], | |
| record_agent_workflow_event: Callable[..., None], | |
| send_to_dlq: Callable[[AgentMessage, ValidationResult], Awaitable[None]], | |
| schedule_background_task_fn: BackgroundTaskScheduler, | |
| background_tasks: set[object], | |
| ) -> None: | |
| if isinstance(result.metadata, dict): | |
| result.metadata.setdefault("rejection_stage", failure_stage) | |
| result.metadata.setdefault( | |
| "flywheel_decision_event", | |
| build_decision_event(msg, result).model_dump(mode="json"), | |
| ) | |
| if increment_failed_count: | |
| failed_counter_increment() | |
| rejection_reason = extract_rejection_reason(result) | |
| schedule_governance_audit_event(msg, result) | |
| await persist_flywheel_decision_event(msg, result) | |
| record_agent_workflow_event( | |
| event_type="gate_failure", | |
| msg=msg, | |
| reason=rejection_reason, | |
| ) | |
| if msg.priority == Priority.CRITICAL: | |
| record_agent_workflow_event( | |
| event_type="rollback_trigger", | |
| msg=msg, | |
| reason="critical_message_rejected", | |
| ) | |
| schedule_background_task_fn(send_to_dlq(msg, result), background_tasks) | |
| def schedule_governance_audit_event( | |
| self, | |
| *, | |
| msg: AgentMessage, | |
| result: ValidationResult, | |
| audit_client: object | None, | |
| schedule_background_task_fn: BackgroundTaskScheduler, | |
| background_tasks: set[object], | |
| emit_governance_audit_event: Callable[[AgentMessage, ValidationResult], Awaitable[None]], | |
| ) -> None: | |
| metadata = result.metadata if isinstance(result.metadata, dict) else {} | |
| if audit_client is None: | |
| return | |
| has_governance_artifacts = ( | |
| "governance_decision" in metadata or "governance_receipt" in metadata | |
| ) | |
| if not result.is_valid and not has_governance_artifacts: | |
| schedule_background_task_fn( | |
| emit_governance_audit_event(msg, result), | |
| background_tasks, | |
| ) | |
| return | |
| if not has_governance_artifacts: | |
| return | |
| schedule_background_task_fn( | |
| emit_governance_audit_event(msg, result), | |
| background_tasks, | |
| ) | |
| async def emit_governance_audit_event( | |
| self, | |
| *, | |
| msg: AgentMessage, | |
| result: ValidationResult, | |
| audit_client: object | None, | |
| extract_rejection_reason: Callable[[ValidationResult], str], | |
| governance_core_mode: str, | |
| ) -> None: | |
| if audit_client is None: | |
| return | |
| metadata = result.metadata if isinstance(result.metadata, dict) else {} | |
| details: JSONDict = { | |
| "message_id": msg.message_id, | |
| "tenant_id": msg.tenant_id, | |
| "from_agent": msg.from_agent, | |
| "to_agent": msg.to_agent, | |
| "message_type": get_enum_value(msg.message_type), | |
| "constitutional_hash": msg.constitutional_hash, | |
| "result_valid": result.is_valid, | |
| "rejection_reason": extract_rejection_reason(result) if not result.is_valid else None, | |
| "rejection_stage": metadata.get("rejection_stage"), | |
| "governance_core_mode": metadata.get("governance_core_mode", governance_core_mode), | |
| "governance_decision": metadata.get("governance_decision"), | |
| "governance_receipt": metadata.get("governance_receipt"), | |
| "governance_shadow": metadata.get("governance_shadow"), | |
| } | |
| try: | |
| if hasattr(audit_client, "log_event"): | |
| await audit_client.log_event( | |
| event_type="message_processor.governance_decision", | |
| details=details, | |
| correlation_id=msg.message_id, | |
| ) | |
| elif hasattr(audit_client, "log"): | |
| await audit_client.log( | |
| action="message_processor.governance_decision", | |
| resource_type="agent_message", | |
| resource_id=msg.message_id, | |
| details=details, | |
| ) | |
| except (AttributeError, OSError, RuntimeError, TypeError, ValueError) as exc: | |
| logger.warning( | |
| "governance_audit_event_failed", | |
| message_id=msg.message_id, | |
| error=str(exc), | |
| ) | |
| async def persist_flywheel_decision_event( | |
| self, | |
| *, | |
| msg: AgentMessage, | |
| result: ValidationResult, | |
| workflow_repository: Any | None, | |
| ) -> None: | |
| if workflow_repository is None: | |
| return | |
| try: | |
| await workflow_repository.save_decision_event(build_decision_event(msg, result)) | |
| except (AttributeError, OSError, RuntimeError, TypeError, ValueError) as exc: | |
| logger.warning( | |
| "flywheel_decision_event_persistence_failed", | |
| message_id=msg.message_id, | |
| tenant_id=msg.tenant_id, | |
| error=str(exc), | |
| ) | |
| async def send_to_dlq( | |
| self, | |
| *, | |
| msg: AgentMessage, | |
| result: ValidationResult, | |
| get_dlq_redis: Callable[[], Awaitable[Any]], | |
| ) -> None: | |
| try: | |
| import json | |
| client = await get_dlq_redis() | |
| dlq_entry = build_dlq_entry(msg, result, time.time()) | |
| await client.lpush("acgs:dlq:messages", json.dumps(dlq_entry)) | |
| await client.ltrim("acgs:dlq:messages", 0, 9999) | |
| logger.info("dlq_message_stored", message_id=msg.message_id) | |
| except (ImportError, OSError, RuntimeError, TypeError, ValueError) as exc: | |
| logger.warning(f"DLQ write failed (non-fatal): {exc}") | |
| raise | |
Xet Storage Details
- Size:
- 9.19 kB
- Xet hash:
- 1b8657cdffea8f0fc03289c95e33ea68829bfc6eb56270d5ddcda48180cec2b5
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.