164 行
6.8 KiB
Python
164 行
6.8 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""Focused proof that enabled P5-C Companion sinks deny before egress."""
|
|
from __future__ import annotations
|
|
|
|
import importlib
|
|
import inspect
|
|
import json
|
|
from pathlib import Path
|
|
import sys
|
|
from types import SimpleNamespace
|
|
import types
|
|
import unittest
|
|
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
|
import _host_stub # noqa: E402
|
|
|
|
_host_stub.install()
|
|
event_module = importlib.import_module("astrbot.api.event")
|
|
event_module.filter.EventMessageType = SimpleNamespace(
|
|
ALL="ALL", PRIVATE_MESSAGE="PRIVATE_MESSAGE", GROUP_MESSAGE="GROUP_MESSAGE"
|
|
)
|
|
|
|
PACKAGE = "_p5c_gate_companion"
|
|
if PACKAGE not in sys.modules:
|
|
package = types.ModuleType(PACKAGE)
|
|
package.__path__ = [str(Path(__file__).resolve().parents[1])]
|
|
sys.modules[PACKAGE] = package
|
|
|
|
gate = importlib.import_module(f"{PACKAGE}.p5c_gate")
|
|
main = importlib.import_module(f"{PACKAGE}.main")
|
|
private_image = importlib.import_module(f"{PACKAGE}.private_image")
|
|
forward = importlib.import_module(f"{PACKAGE}.forward_message")
|
|
tool_actions = importlib.import_module(f"{PACKAGE}.llm_tool_actions")
|
|
|
|
|
|
class _Host:
|
|
enable_p5c_raw_image_provider_gate = True
|
|
enable_p5c_group_image_vision_gate = True
|
|
enable_p5c_context_image_caption_gate = True
|
|
enable_p5c_tool_parameter_gate = True
|
|
|
|
|
|
class _ImageHost(_Host):
|
|
async def _prepare_private_image_sources_for_model(self, *_args, **_kwargs):
|
|
raise AssertionError("enabled raw-image gate must stop before image preparation")
|
|
|
|
|
|
class _ForwardHost(_Host):
|
|
forward_message_image_vision = True
|
|
|
|
async def _prepare_private_image_sources_for_model(self, *_args, **_kwargs):
|
|
raise AssertionError("enabled forward-image gate must stop before image preparation")
|
|
|
|
|
|
class _ToolHost(_Host):
|
|
def _atrelay_target_umo_candidates(self, *_args, **_kwargs):
|
|
raise AssertionError("enabled tool gate must stop before target resolution")
|
|
|
|
|
|
class P5CCompanionGateTests(unittest.IsolatedAsyncioTestCase):
|
|
async def test_default_off_does_not_change_paths_and_audit_has_no_carrier_values(self) -> None:
|
|
off = SimpleNamespace()
|
|
self.assertTrue(gate.p5c_gate_allows(off, gate.RAW_IMAGE_PROVIDER_SINK))
|
|
|
|
host = _Host()
|
|
host.event = "event-secret"
|
|
self.assertFalse(gate.p5c_gate_allows(host, gate.RAW_IMAGE_PROVIDER_SINK))
|
|
audit = host._p5c_denial_audit[-1]
|
|
self.assertEqual(
|
|
{"sink", "outcome", "reason_code", "ref_hash"},
|
|
set(audit),
|
|
)
|
|
self.assertNotIn("event-secret", repr(audit))
|
|
|
|
bound = _Host()
|
|
bound._p5c_gate_allows = main.PrivateCompanionPlugin._p5c_gate_allows.__get__(bound, _Host)
|
|
self.assertFalse(bound._p5c_gate_allows(gate.TOOL_PARAMETER_SINK))
|
|
|
|
async def test_enabled_media_sinks_stop_before_prepare_task_and_context_mutation(self) -> None:
|
|
image_host = _ImageHost()
|
|
result = await private_image.PrivateImageMixin._transcribe_private_inbound_images(
|
|
image_host, ["https://example.invalid/raw.png"]
|
|
)
|
|
self.assertEqual("", result)
|
|
|
|
group_host = _Host()
|
|
group_request = SimpleNamespace(system_prompt="unchanged", prompt="")
|
|
appended = await private_image.PrivateImageMixin._append_group_image_understanding_to_request(
|
|
group_host, SimpleNamespace(), group_request
|
|
)
|
|
self.assertFalse(appended)
|
|
self.assertEqual("unchanged", group_request.system_prompt)
|
|
|
|
context_host = _Host()
|
|
caption = await private_image.PrivateImageMixin._caption_context_image_sources(
|
|
context_host, ["https://example.invalid/context.png"]
|
|
)
|
|
self.assertEqual("", caption)
|
|
|
|
task = private_image.PrivateImageMixin._start_group_image_understanding(
|
|
group_host, SimpleNamespace()
|
|
)
|
|
self.assertIsNone(task)
|
|
|
|
request = SimpleNamespace(contexts=["[image placeholder]"])
|
|
result = await private_image.PrivateImageMixin._enrich_request_context_image_placeholders(
|
|
context_host, SimpleNamespace(), request
|
|
)
|
|
self.assertEqual({"contexts": 0, "replaced": 0, "missed": 0}, result)
|
|
self.assertEqual(["[image placeholder]"], request.contexts)
|
|
|
|
forward_host = _ForwardHost()
|
|
result = await forward.ForwardMessageMixin._transcribe_forward_message_images(
|
|
forward_host, SimpleNamespace(), ["https://example.invalid/forward.png"]
|
|
)
|
|
self.assertEqual("", result)
|
|
|
|
async def test_enabled_tool_gate_stops_before_target_resolution_and_final_send(self) -> None:
|
|
host = _ToolHost()
|
|
result = await tool_actions.LlmToolActionsMixin._pc_send_to_group_impl(
|
|
host, SimpleNamespace(), message="secret", group_id="123"
|
|
)
|
|
self.assertEqual(gate.P5C_CONTROLLED_DENY_REASON, result)
|
|
|
|
ok, reason, used_umo = await tool_actions.LlmToolActionsMixin._send_atrelay_chain_to_target(
|
|
host,
|
|
SimpleNamespace(),
|
|
message_type="group",
|
|
target_id="123",
|
|
chain=[],
|
|
)
|
|
self.assertFalse(ok)
|
|
self.assertEqual(gate.P5C_CONTROLLED_DENY_REASON, reason)
|
|
self.assertEqual("", used_umo)
|
|
|
|
scheduled = await tool_actions.LlmToolActionsMixin._pc_schedule_group_relay_impl(
|
|
host, SimpleNamespace(), message="secret", group_id="123"
|
|
)
|
|
self.assertEqual(gate.P5C_CONTROLLED_DENY_REASON, scheduled)
|
|
|
|
async def test_direct_raw_mount_is_gated_before_source_preparation_and_schema_is_default_off(self) -> None:
|
|
source = inspect.getsource(main.PrivateCompanionPlugin.inject_humanized_state)
|
|
buffered_start = source.index("direct_image_mounted = False")
|
|
direct_start = source.index('buffered_image_mode == "direct"', buffered_start)
|
|
gate_at = source.index("raw_image_provider_allowed = self._p5c_gate_allows(RAW_IMAGE_PROVIDER_SINK)", buffered_start)
|
|
prepare_at = source.index("self._private_image_sources_for_astrbot_request", direct_start)
|
|
self.assertLess(gate_at, direct_start)
|
|
self.assertLess(gate_at, prepare_at)
|
|
|
|
fallback_start = source.index('"image.fallback"', direct_start)
|
|
fallback_end = source.index('elif bool(getattr(event, "private_companion_deferred_private_image_only_ready"', fallback_start)
|
|
fallback = source[fallback_start:fallback_end]
|
|
self.assertIn("if raw_image_provider_allowed else \"\"", fallback)
|
|
self.assertNotIn('"\\n".join(f"- {path}" for path in buffered_images),', fallback)
|
|
|
|
schema = json.loads((Path(__file__).resolve().parents[1] / "_conf_schema.json").read_text(encoding="utf-8"))
|
|
items = schema["p5c_safety_config"]["items"]
|
|
self.assertEqual(set(gate.P5C_SINK_FLAGS.values()), set(items))
|
|
self.assertTrue(all(entry["default"] is False for entry in items.values()))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|