From 8faf8b5ef9c43d6f9cb6164ab079c978f4c26c95 Mon Sep 17 00:00:00 2001 From: Codex Local Date: Thu, 30 Jul 2026 07:31:12 +0800 Subject: [PATCH] fix(c7): close common safety and lifecycle gaps --- bot_personal_outbox.py | 29 +++- daily_state.py | 5 +- main.py | 219 ++++++++++++++++++------- tests/test_c7_concurrency_lifecycle.py | 56 +++++++ 4 files changed, 243 insertions(+), 66 deletions(-) create mode 100644 tests/test_c7_concurrency_lifecycle.py diff --git a/bot_personal_outbox.py b/bot_personal_outbox.py index 1adb596..29924d8 100644 --- a/bot_personal_outbox.py +++ b/bot_personal_outbox.py @@ -13,12 +13,14 @@ from dataclasses import dataclass from datetime import datetime, timezone import hashlib import json +import logging from typing import Any, Awaitable, Callable, Mapping from .bot_personal_dto import BotPersonalArchiveDTO, build_bot_personal_dto OUTBOX_STATES = frozenset({"pending", "retry", "sent", "deduplicated", "dead_letter", "invalid"}) +logger = logging.getLogger(__name__) def _now_iso() -> str: @@ -80,6 +82,7 @@ class BotPersonalOutbox: max_attempts: int = 5, base_backoff_seconds: float = 30.0, max_backoff_seconds: float = 3600.0, + background_task: Callable[[Awaitable[Any], str], Any] | None = None, ) -> None: self.data = data self.save = save @@ -87,6 +90,8 @@ class BotPersonalOutbox: self.max_attempts = max(1, int(max_attempts or 5)) self.base_backoff_seconds = max(0.0, float(base_backoff_seconds or 30.0)) self.max_backoff_seconds = max(self.base_backoff_seconds, float(max_backoff_seconds or 3600.0)) + self.background_task = background_task + self._persist_tasks: set[asyncio.Task] = set() self._lock = asyncio.Lock() entries = self.data.setdefault("bot_personal_outbox", []) if not isinstance(entries, list): @@ -109,12 +114,34 @@ class BotPersonalOutbox: try: result = self.save() if asyncio.iscoroutine(result) or hasattr(result, "__await__"): - asyncio.create_task(result) + if callable(self.background_task): + self.background_task(result, "bot_personal_outbox_save") + return + try: + task = asyncio.create_task(result) + except RuntimeError: + closer = getattr(result, "close", None) + if callable(closer): + closer() + return + self._persist_tasks.add(task) + task.add_done_callback(self._collect_persist_task) except Exception: # The in-memory queue remains authoritative for this process; the # next normal store save can still persist the already-mutated data. return + def _collect_persist_task(self, task: asyncio.Task) -> None: + self._persist_tasks.discard(task) + if task.cancelled(): + return + try: + error = task.exception() + except asyncio.CancelledError: + return + if error is not None: + logger.warning("Bot Personal outbox save task failed: %s", error, exc_info=error) + @staticmethod def _key(memory_type: str, idempotency_key: str) -> str: return f"{str(memory_type or '').strip()}::{str(idempotency_key or '').strip()}" diff --git a/daily_state.py b/daily_state.py index 130fa21..ce829ce 100644 --- a/daily_state.py +++ b/daily_state.py @@ -15913,8 +15913,9 @@ class DailyStateMixin: } if memory_companion_proactive_payload: await self._memory_companion_record_proactive_message(**memory_companion_proactive_payload) - asyncio.create_task( - self._refresh_persona_relationship(user_id, current_snapshot, trigger="proactive") + self._create_lifecycle_background_task( + self._refresh_persona_relationship(user_id, current_snapshot, trigger="proactive"), + label="refresh_persona_relationship_proactive", ) await self._run_proactive_maintenance_tasks() diff --git a/main.py b/main.py index bbbfd5e..604e923 100644 --- a/main.py +++ b/main.py @@ -2,6 +2,7 @@ from __future__ import annotations import asyncio import base64 +from contextlib import asynccontextmanager import functools import gc import hashlib @@ -2375,6 +2376,10 @@ class PrivateCompanionPlugin( self._bot_personal_outbox = BotPersonalOutbox( self.data, save=lambda: self._schedule_data_save(delay=0.5), + background_task=lambda operation, label: self._create_lifecycle_background_task( + operation, + label=label, + ), ) self.unified_person_registry = UnifiedPersonRegistry(self.data) self._apply_tts_runtime_overrides() @@ -2841,10 +2846,50 @@ class PrivateCompanionPlugin( def discard_finished_task(finished: asyncio.Task) -> None: if self._startup_background_tasks.get(label) is finished: self._startup_background_tasks.pop(label, None) + if finished.cancelled(): + return + try: + error = finished.exception() + except asyncio.CancelledError: + return + if error is not None: + logger.warning( + "[PrivateCompanion] 启动后台任务异常结束: task=%s error=%s", + _single_line(label, 100) or "startup", + _single_line(error, 180), + exc_info=(type(error), error, error.__traceback__), + ) task.add_done_callback(discard_finished_task) return task + @asynccontextmanager + async def _temporarily_release_data_lock(self): + """Release the data lock only around an external await, then reacquire it. + + Callers use this inside an existing ``async with self._data_lock`` block. + Reacquisition is cancellation-safe so a cancelled visual/LLM operation + cannot leave the shared state lock open. + """ + + lock = getattr(self, "_data_lock", None) + if lock is None or not lock.locked(): + yield + return + lock.release() + reacquire_cancelled = False + try: + yield + finally: + while True: + try: + await lock.acquire() + break + except asyncio.CancelledError: + reacquire_cancelled = True + if reacquire_cancelled: + raise asyncio.CancelledError + def _create_lifecycle_background_task( self, operation: Any, @@ -11199,17 +11244,21 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge tts_value = tts_parts[1].strip() if len(tts_parts) >= 2 else "" response = self._set_tts_voice_language_from_command(tts_value) elif action in companion_manual_confirm_actions: - response = await self._companion_manual_apply_pending_config(event) + async with self._temporarily_release_data_lock(): + response = await self._companion_manual_apply_pending_config(event) elif action in companion_manual_cancel_actions: response = self._companion_manual_cancel_pending_config(event) elif action in companion_manual_setting_actions: - response = await self._companion_manual_apply_setting_command(event, value) + async with self._temporarily_release_data_lock(): + response = await self._companion_manual_apply_setting_command(event, value) elif action in companion_manual_query_actions: response = "正在结合说明书和当前运行状态做诊断。" elif action in {"参考图", "人设参考图", "自拍参考图"}: - response, response_image_path = await self._photo_reference_command_payload(event, user_id, value) + async with self._temporarily_release_data_lock(): + response, response_image_path = await self._photo_reference_command_payload(event, user_id, value) elif action == "参考图库": - response, response_image_path = await self._photo_reference_library_command_payload(event, user_id, value) + async with self._temporarily_release_data_lock(): + response, response_image_path = await self._photo_reference_library_command_payload(event, user_id, value) elif action in daily_outfit_view_actions: response, response_image_path = self._daily_outfit_command_payload() elif action in image_api_status_actions: @@ -11276,8 +11325,9 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge elif action in {"书柜密码", "夹层密码", "抽屉密码", "书柜暗格"}: response = "这个要直接问我本人。她会不会说、怎么说,要看当时的人格和心情。" elif bookshelf_password_output_requested: - password = await self._ensure_bookshelf_password_async() - password_reason = await self._ensure_bookshelf_password_reason_async(password) + async with self._temporarily_release_data_lock(): + password = await self._ensure_bookshelf_password_async() + password_reason = await self._ensure_bookshelf_password_reason_async(password) secret = self.data.get("bookshelf_secret", {}) if isinstance(self.data.get("bookshelf_secret"), dict) else {} response = ( "当前书柜夹层密码:\n" @@ -11292,7 +11342,8 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge self.data["bookshelf_secret"] = secret secret.pop("password", None) secret["reset_at"] = _now_ts() - await self._ensure_bookshelf_password_async() + async with self._temporarily_release_data_lock(): + await self._ensure_bookshelf_password_async() self._save_data_sync() response = "已重新设置书柜夹层密码。需要查看真实密码可用:陪伴 输出夹层密码" elif action in {"发说说", "发QQ空间", "发布说说", "空间发布", "发布空间"}: @@ -11906,7 +11957,8 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge and self._private_event_has_image_safe(event, label="private_text_image") ): try: - persisted_images = await self._persist_private_inbound_images(event, user_id) + async with self._temporarily_release_data_lock(): + persisted_images = await self._persist_private_inbound_images(event, user_id) usable_images = [source for source in persisted_images if self._private_image_source_to_model_url(source)] except Exception as exc: missing = _missing_optional_model_dependency(exc) @@ -11948,15 +12000,16 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge setattr(event, "private_companion_delayed_image_mode", image_mode) if image_mode == "caption": try: - vision_text = _single_line( - await self._transcribe_private_inbound_images( - usable_images[:5], - umo=umo, - user_text=text, - force_contextual=self._private_image_user_mentions_combo_result(text) or self._private_image_user_has_specific_vision_request(text), - ), - self._private_image_vision_text_limit(len(usable_images)), - ) + async with self._temporarily_release_data_lock(): + vision_text = _single_line( + await self._transcribe_private_inbound_images( + usable_images[:5], + umo=umo, + user_text=text, + force_contextual=self._private_image_user_mentions_combo_result(text) or self._private_image_user_has_specific_vision_request(text), + ), + self._private_image_vision_text_limit(len(usable_images)), + ) except Exception as exc: missing = _missing_optional_model_dependency(exc) if not missing: @@ -12011,7 +12064,8 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge ) buffers = getattr(self, "_semantic_message_buffers", None) if isinstance(buffers, dict) and isinstance(buffers.get(key), dict): - persisted_images = await self._persist_private_inbound_images(event, user_id) + async with self._temporarily_release_data_lock(): + persisted_images = await self._persist_private_inbound_images(event, user_id) has_model_usable_image = any(self._private_image_source_to_model_url(source) for source in persisted_images) if not persisted_images: buffers.pop(key, None) @@ -12100,14 +12154,15 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge ) else: try: - smart_wait = await self._smart_message_debounce_wait_seconds_for_event( - event, - key=key, - text=text, - sender_id=user_id, - sender_name=sender_display_name, - private_chat=True, - ) + async with self._temporarily_release_data_lock(): + smart_wait = await self._smart_message_debounce_wait_seconds_for_event( + event, + key=key, + text=text, + sender_id=user_id, + sender_name=sender_display_name, + private_chat=True, + ) except Exception as exc: missing = _missing_optional_model_dependency(exc) if not missing: @@ -12232,7 +12287,10 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge "created_at": _now_ts(), "local": deepcopy(intent_profile), } - asyncio.create_task(self._refine_inbound_emotion_with_model(user_id, text, deepcopy(intent_profile))) + self._create_lifecycle_background_task( + self._refine_inbound_emotion_with_model(user_id, text, deepcopy(intent_profile)), + label="inbound_emotion_refine", + ) else: self._update_relationship_state_from_intent(user, intent_profile) if is_target_user and self._cancel_inbound_conflicting_greeting( @@ -12323,18 +12381,28 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge self._stop_private_reply_after_user_rest_signal(event, user_id, rest_silence_early_text or text) return if is_target_user and schedule_adjustment_applied: - asyncio.create_task(self._kick_proactive_loop_once()) + self._create_lifecycle_background_task( + self._kick_proactive_loop_once(), + label="kick_proactive_loop_inbound", + ) if response: await self._reply(event, response) event.stop_event() elif is_target_user: pass if is_target_user: - asyncio.create_task( - self._refresh_persona_relationship(user_id, user_snapshot, trigger="inbound") + self._create_lifecycle_background_task( + self._refresh_persona_relationship(user_id, user_snapshot, trigger="inbound"), + label="refresh_persona_relationship_inbound", + ) + self._create_lifecycle_background_task( + self._maybe_refresh_companion_memory(user_id, user_snapshot), + label="refresh_companion_memory_inbound", + ) + self._create_lifecycle_background_task( + self._maybe_refresh_dialogue_episode(user_id, user_snapshot), + label="refresh_dialogue_episode_inbound", ) - asyncio.create_task(self._maybe_refresh_companion_memory(user_id, user_snapshot)) - asyncio.create_task(self._maybe_refresh_dialogue_episode(user_id, user_snapshot)) def _record_c3_inbound_activity( self, @@ -12380,7 +12448,10 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge if result is not None and scope == "private": recorder = getattr(self, "_memory_companion_record_observed_activity", None) if callable(recorder): - asyncio.create_task(recorder(result)) + self._create_lifecycle_background_task( + recorder(result), + label="record_observed_activity", + ) return result except Exception as exc: logger.debug( @@ -12642,8 +12713,14 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge _single_line(text, 80), _single_line(existing_reply_preview, 120), ) - asyncio.create_task(self._maybe_refresh_group_episode(group_id, group_snapshot)) - asyncio.create_task(self._maybe_refresh_group_slang_meanings(group_id, group_snapshot)) + self._create_lifecycle_background_task( + self._maybe_refresh_group_episode(group_id, group_snapshot), + label="refresh_group_episode_existing_reply", + ) + self._create_lifecycle_background_task( + self._maybe_refresh_group_slang_meanings(group_id, group_snapshot), + label="refresh_group_slang_existing_reply", + ) return if self._group_llm_reply_blocked(group_id): logger.debug( @@ -12766,14 +12843,15 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge ) high_intensity_state = self._group_high_intensity_state(group) if not resting_mention_notice: - continuation = await self._group_message_is_bot_continuation( - group, - sender_id, - sender_name, - scene, - text, - allow_llm=False, - ) + async with self._temporarily_release_data_lock(): + continuation = await self._group_message_is_bot_continuation( + group, + sender_id, + sender_name, + scene, + text, + allow_llm=False, + ) if continuation is None: if high_intensity_state.get("active"): continuation = False @@ -13001,7 +13079,8 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge setattr(event, "private_companion_group_wakeup_state_effect", dict(wakeup_state_effect)) group_reference_media_with_text = False if talking_to_bot and text: - group_reference_media_with_text = await self._event_references_media_or_forward_with_text(event, text) + async with self._temporarily_release_data_lock(): + group_reference_media_with_text = await self._event_references_media_or_forward_with_text(event, text) if group_reference_media_with_text: logger.info( "[PrivateCompanion] 群聊引用媒体/合并消息附带文字,跳过群聊收口等待: group=%s sender=%s text=%s", @@ -13044,13 +13123,14 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge event.stop_event() return if talking_to_bot and not high_intensity_merge_active and not group_reference_media_with_text: - air_guard = await self._group_air_reply_guard_decision( - group, - sender_id=sender_id, - sender_name=sender_name, - text=text, - scene=scene, - ) + async with self._temporarily_release_data_lock(): + air_guard = await self._group_air_reply_guard_decision( + group, + sender_id=sender_id, + sender_name=sender_name, + text=text, + scene=scene, + ) if isinstance(air_guard, dict) and air_guard.get("block"): self._capture_group_observation_once( group, @@ -13091,14 +13171,15 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge text=text, now=_now_ts(), ) - group_smart_wait = await self._smart_message_debounce_wait_seconds_for_event( - event, - key=group_buffer_key, - text=text, - sender_id=sender_id, - sender_name=sender_name, - private_chat=False, - ) + async with self._temporarily_release_data_lock(): + group_smart_wait = await self._smart_message_debounce_wait_seconds_for_event( + event, + key=group_buffer_key, + text=text, + sender_id=sender_id, + sender_name=sender_name, + private_chat=False, + ) group_smart_result = getattr(event, "private_companion_smart_message_debounce_result", None) group_smart_decision = str(group_smart_result.get("decision") or "") if isinstance(group_smart_result, dict) else "" group_smart_handled = group_smart_decision in {"complete", "incomplete"} @@ -13159,12 +13240,24 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge event.stop_event() return if registration_payload and registration_payload.get("user_id"): - asyncio.create_task(self._refresh_worldbook_self_registration_impression(registration_payload)) + self._create_lifecycle_background_task( + self._refresh_worldbook_self_registration_impression(registration_payload), + label="refresh_worldbook_self_registration_impression", + ) if share_scheduled: - asyncio.create_task(self._kick_proactive_loop_once()) + self._create_lifecycle_background_task( + self._kick_proactive_loop_once(), + label="kick_proactive_loop_group", + ) if not group_snapshot_high_intensity.get("active"): - asyncio.create_task(self._maybe_refresh_group_episode(group_id, group_snapshot)) - asyncio.create_task(self._maybe_refresh_group_slang_meanings(group_id, group_snapshot)) + self._create_lifecycle_background_task( + self._maybe_refresh_group_episode(group_id, group_snapshot), + label="refresh_group_episode", + ) + self._create_lifecycle_background_task( + self._maybe_refresh_group_slang_meanings(group_id, group_snapshot), + label="refresh_group_slang", + ) await self._maybe_group_interject(event, group_snapshot, text) else: logger.info( diff --git a/tests/test_c7_concurrency_lifecycle.py b/tests/test_c7_concurrency_lifecycle.py new file mode 100644 index 0000000..eeb899f --- /dev/null +++ b/tests/test_c7_concurrency_lifecycle.py @@ -0,0 +1,56 @@ +from __future__ import annotations + +import asyncio +from pathlib import Path +import sys +import types +import unittest + +ROOT = Path(__file__).resolve().parents[1] + +PACKAGE_NAME = "c7_companion_test_package" +package = types.ModuleType(PACKAGE_NAME) +package.__path__ = [str(ROOT)] +sys.modules.setdefault(PACKAGE_NAME, package) + +from c7_companion_test_package.bot_personal_outbox import BotPersonalOutbox + + +class OutboxLifecycleTests(unittest.TestCase): + def test_async_save_uses_lifecycle_callback_when_provided(self): + labels: list[str] = [] + + def create_task(operation, label): + labels.append(label) + operation.close() + return None + + async def save(): + return None + + outbox = BotPersonalOutbox({}, save=save, background_task=create_task) + asyncio.run(asyncio.to_thread(outbox._persist)) + self.assertEqual(["bot_personal_outbox_save"], labels) + + +class CompanionConcurrencyStaticTests(unittest.TestCase): + def test_data_lock_external_awaits_use_temporary_release_context(self): + source = (ROOT / "main.py").read_text(encoding="utf-8") + self.assertIn("async def _temporarily_release_data_lock", source) + self.assertGreaterEqual(source.count("async with self._temporarily_release_data_lock()"), 12) + self.assertIn('label="refresh_group_episode"', source) + self.assertIn('label="refresh_persona_relationship_inbound"', source) + + def test_untracked_main_background_tasks_are_not_left_in_message_paths(self): + source = (ROOT / "main.py").read_text(encoding="utf-8") + for marker in ( + "asyncio.create_task(self._refine_inbound_emotion_with_model", + "asyncio.create_task(self._maybe_refresh_companion_memory", + "asyncio.create_task(self._maybe_refresh_group_episode", + "asyncio.create_task(self._kick_proactive_loop_once", + ): + self.assertNotIn(marker, source) + + +if __name__ == "__main__": + unittest.main()