fix(ci): stabilize event and web agent checks

app/runtime/event/contracts.py

@@ -143,13 +143,13 @@ _SNAPSHOT_EVENTS = {
     ChainEventType.SubscribeCompletionCheck,
 }
 
-_INPUT_MODELS = {
+_INPUT_MODELS: dict[EventType | ChainEventType, type[BaseModel]] = {
     ChainEventType.ResourceSelection: event_schemas.ResourceSelectionInputContractData,
     ChainEventType.ResourceDownload: event_schemas.ResourceDownloadInputContractData,
     ChainEventType.SubscribeCompletionCheck: event_schemas.SubscribeCompletionCheckInputContractData,
 }
 
-_OUTPUT_MODELS = {
+_OUTPUT_MODELS: dict[EventType | ChainEventType, type[BaseModel]] = {
     ChainEventType.ResourceSelection: event_schemas.ResourceSelectionOutputContractData,
     ChainEventType.ResourceDownload: event_schemas.ResourceDownloadOutputContractData,
     ChainEventType.SubscribeCompletionCheck: event_schemas.SubscribeCompletionCheckOutputContractData,
@@ -213,9 +213,14 @@ def _build_contract(event_type: EventType | ChainEventType) -> EventContract:
     )
 
 
-EVENT_CONTRACTS = {
+_ALL_EVENT_TYPES: tuple[EventType | ChainEventType, ...] = (
+    *tuple(EventType),
+    *tuple(ChainEventType),
+)
+
+EVENT_CONTRACTS: dict[EventType | ChainEventType, EventContract] = {
     event_type: _build_contract(event_type)
-    for event_type in (*tuple(EventType), *tuple(ChainEventType))
+    for event_type in _ALL_EVENT_TYPES
 }
 
 

app/runtime/events.py

@@ -357,6 +357,8 @@ class EventManager(metaclass=Singleton):
                 return False
             try:
                 owner = object()
+                completion: concurrent.futures.Future[Any] = concurrent.futures.Future()
+                self.__sync_handles[owner] = completion
 
                 def _tracked_sync() -> Any:
                     """在同步 handler 调用栈中发布当前事件 owner。"""
@@ -368,14 +370,25 @@ class EventManager(metaclass=Singleton):
 
                 handle = self.__executor.submit(_tracked_sync)
             except RuntimeError:
+                self.__sync_handles.pop(owner, None)
                 logger.warning("同步事件处理器无法投递，线程池已停止")
                 return False
-            self.__sync_handles[owner] = handle
-            handle.add_done_callback(
-                lambda _completed, current_owner=owner: (
-                    self.__remove_sync_handle(current_owner)
-                )
-            )
+
+            def _complete_sync_handle(
+                    completed: concurrent.futures.Future[Any],
+            ) -> None:
+                """把真实线程句柄的结果转移到已登记的结算句柄。"""
+                if completed.cancelled():
+                    completion.cancel()
+                else:
+                    error = completed.exception()
+                    if error is not None:
+                        completion.set_exception(error)
+                    else:
+                        completion.set_result(completed.result())
+                self.__remove_sync_handle(owner)
+
+            handle.add_done_callback(_complete_sync_handle)
         return True
 
     def __remove_sync_handle(self, owner: object) -> None: