Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

tests/tools/test_send_message_target_parse.py

@@ -0,0 +1,598 @@
+"""Parser-only and lightweight routing tests for send_message targets.
+
+These stay separate from ``test_send_message_tool.py`` because that module
+skips wholesale when optional Telegram dependencies are not installed.
+"""
+
+import asyncio
+import json
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, patch
+
+from gateway.config import Platform
+from tools.send_message_tool import _parse_target_ref, _send_to_platform, send_message_tool
+
+
+def _run_async_immediately(coro):
+    return asyncio.run(coro)
+
+
+def test_buzz_uuid_target_is_explicit() -> None:
+    channel_id = "31b543d5-80d4-4df5-8a5c-cefca1a58fdd"
+
+    assert _parse_target_ref("buzz", channel_id) == (channel_id, None, True)
+
+
+def test_live_buzz_media_delivers_every_file_with_reply_metadata(tmp_path) -> None:
+    from gateway.platforms.base import SendResult
+
+    platform = Platform("buzz")
+    first = tmp_path / "first.txt"
+    second = tmp_path / "second.pdf"
+    first.write_text("first", encoding="utf-8")
+    second.write_text("second", encoding="utf-8")
+    calls = []
+
+    class Adapter:
+        async def send(self, *, chat_id, content, metadata=None):
+            calls.append(("text", content, metadata))
+            return SendResult(success=True, message_id="evt-text")
+
+        async def send_document(self, chat_id, file_path, **kwargs):
+            calls.append(("document", file_path, kwargs))
+            return SendResult(success=True, message_id=f"evt-{len(calls)}")
+
+    runner = SimpleNamespace(adapters={platform: Adapter()})
+    with patch("gateway.run._gateway_runner_ref", return_value=runner):
+        result = asyncio.run(
+            _send_to_platform(
+                platform,
+                SimpleNamespace(enabled=True, token=None, extra={}),
+                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
+                "attached files",
+                thread_id="reply-root",
+                media_files=[(str(first), False), (str(second), False)],
+            )
+        )
+
+    assert result["success"] is True
+    assert result["media_delivered"] is True
+    assert calls == [
+        ("text", "attached files", {"thread_id": "reply-root"}),
+        ("document", str(first), {"caption": None, "reply_to": "reply-root", "metadata": {"thread_id": "reply-root"}}),
+        ("document", str(second), {"caption": None, "reply_to": "reply-root", "metadata": {"thread_id": "reply-root"}}),
+    ]
+
+
+def test_live_buzz_single_image_uses_caption_without_duplicate_text(tmp_path) -> None:
+    from gateway.platforms.base import SendResult
+
+    platform = Platform("buzz")
+    image = tmp_path / "shot.png"
+    image.write_bytes(b"png")
+    calls = []
+
+    class Adapter:
+        async def send(self, **kwargs):
+            calls.append(("text", kwargs))
+            return SendResult(success=True, message_id="unexpected")
+
+        async def send_image_file(self, chat_id, image_path, **kwargs):
+            calls.append(("image", image_path, kwargs))
+            return SendResult(success=True, message_id="evt-image")
+
+    runner = SimpleNamespace(adapters={platform: Adapter()})
+    with patch("gateway.run._gateway_runner_ref", return_value=runner):
+        result = asyncio.run(
+            _send_to_platform(
+                platform,
+                SimpleNamespace(enabled=True, token=None, extra={}),
+                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
+                "screenshot caption",
+                thread_id="reply-root",
+                media_files=[(str(image), False)],
+            )
+        )
+
+    assert result == {
+        "success": True,
+        "message_id": "evt-image",
+        "media_delivered": True,
+    }
+    assert calls == [
+        ("image", str(image), {"caption": "screenshot caption", "reply_to": "reply-root", "metadata": {"thread_id": "reply-root"}})
+    ]
+
+
+def test_live_buzz_media_failure_is_explicit_not_omitted(tmp_path) -> None:
+    from gateway.platforms.base import SendResult
+
+    platform = Platform("buzz")
+    first = tmp_path / "first.txt"
+    second = tmp_path / "second.txt"
+    first.write_text("first", encoding="utf-8")
+    second.write_text("second", encoding="utf-8")
+    media_calls = []
+
+    class Adapter:
+        async def send(self, **kwargs):
+            return SendResult(success=True, message_id="evt-text")
+
+        async def send_document(self, chat_id, file_path, **kwargs):
+            media_calls.append(file_path)
+            if file_path == str(second):
+                return SendResult(success=False, error="relay rejected upload")
+            return SendResult(success=True, message_id="evt-first")
+
+    runner = SimpleNamespace(adapters={platform: Adapter()})
+    with patch("gateway.run._gateway_runner_ref", return_value=runner):
+        result = asyncio.run(
+            _send_to_platform(
+                platform,
+                SimpleNamespace(enabled=True, token=None, extra={}),
+                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
+                "attached files",
+                media_files=[(str(first), False), (str(second), False)],
+            )
+        )
+
+    assert media_calls == [str(first), str(second)]
+    assert "relay rejected upload" in result["error"]
+    assert "media_delivered" not in result
+
+
+def test_live_buzz_media_only_send_reaches_adapter(tmp_path) -> None:
+    from gateway.platforms.base import SendResult
+
+    platform = Platform("buzz")
+    document = tmp_path / "report.txt"
+    document.write_text("report", encoding="utf-8")
+    media_calls = []
+
+    class Adapter:
+        async def send(self, **kwargs):
+            raise AssertionError("media-only send must not emit an empty text message")
+
+        async def send_document(self, chat_id, file_path, **kwargs):
+            media_calls.append((chat_id, file_path, kwargs))
+            return SendResult(success=True, message_id="evt-document")
+
+    runner = SimpleNamespace(adapters={platform: Adapter()})
+    with patch("gateway.run._gateway_runner_ref", return_value=runner):
+        result = asyncio.run(
+            _send_to_platform(
+                platform,
+                SimpleNamespace(enabled=True, token=None, extra={}),
+                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
+                "",
+                media_files=[(str(document), False)],
+            )
+        )
+
+    assert result == {
+        "success": True,
+        "message_id": "evt-document",
+        "media_delivered": True,
+    }
+    assert len(media_calls) == 1
+    assert media_calls[0][1] == str(document)
+
+
+def test_live_buzz_media_exception_reports_partial_delivery(tmp_path) -> None:
+    from gateway.platforms.base import SendResult
+
+    platform = Platform("buzz")
+    first = tmp_path / "first.txt"
+    second = tmp_path / "second.txt"
+    first.write_text("first", encoding="utf-8")
+    second.write_text("second", encoding="utf-8")
+
+    class Adapter:
+        async def send(self, **kwargs):
+            return SendResult(success=True, message_id="evt-text")
+
+        async def send_document(self, chat_id, file_path, **kwargs):
+            if file_path == str(second):
+                raise RuntimeError("relay transport failed")
+            return SendResult(success=True, message_id="evt-first")
+
+    runner = SimpleNamespace(adapters={platform: Adapter()})
+    with patch("gateway.run._gateway_runner_ref", return_value=runner):
+        result = asyncio.run(
+            _send_to_platform(
+                platform,
+                SimpleNamespace(enabled=True, token=None, extra={}),
+                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
+                "attached files",
+                media_files=[(str(first), False), (str(second), False)],
+            )
+        )
+
+    assert "after 1/2 files" in result["error"]
+    assert "relay transport failed" in result["error"]
+    assert "media_delivered" not in result
+
+
+def test_live_adapter_inherited_media_fallback_is_not_claimed_as_delivery(tmp_path) -> None:
+    from gateway.platforms.base import BasePlatformAdapter, SendResult
+
+    platform = Platform("buzz")
+    document = tmp_path / "report.txt"
+    document.write_text("report", encoding="utf-8")
+
+    class Adapter:
+        name = "Fallback-only"
+        send_document = BasePlatformAdapter.send_document
+
+        async def send(self, **kwargs):
+            return SendResult(success=True, message_id="warning-text-only")
+
+    runner = SimpleNamespace(adapters={platform: Adapter()})
+    with patch("gateway.run._gateway_runner_ref", return_value=runner):
+        result = asyncio.run(
+            _send_to_platform(
+                platform,
+                SimpleNamespace(enabled=True, token=None, extra={}),
+                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
+                "attached",
+                media_files=[(str(document), False)],
+            )
+        )
+
+    assert "does not implement native document delivery" in result["error"]
+    assert "media_delivered" not in result
+
+
+def test_live_buzz_adapter_exception_is_bounded() -> None:
+    platform = Platform("buzz")
+
+    class Adapter:
+        async def send(self, **kwargs):
+            raise RuntimeError("x" * 100_000)
+
+    runner = SimpleNamespace(adapters={platform: Adapter()})
+    with patch("gateway.run._gateway_runner_ref", return_value=runner):
+        result = asyncio.run(
+            _send_to_platform(
+                platform,
+                SimpleNamespace(enabled=True, token=None, extra={}),
+                "31b543d5-80d4-4df5-8a5c-cefca1a58fdd",
+                "hello",
+            )
+        )
+
+    assert result["error"].startswith("Plugin platform send failed: ")
+    assert len(result["error"]) <= 1024
+
+
+def test_send_message_routes_buzz_uuid_without_home_fallback() -> None:
+    buzz_platform = Platform("buzz")
+    buzz_cfg = SimpleNamespace(enabled=True, token=None, extra={})
+    config = SimpleNamespace(
+        platforms={buzz_platform: buzz_cfg},
+        get_home_channel=lambda _platform: SimpleNamespace(chat_id="home-channel"),
+    )
+    channel_id = "31b543d5-80d4-4df5-8a5c-cefca1a58fdd"
+
+    with patch("gateway.config.load_gateway_config", return_value=config), \
+         patch("tools.interrupt.is_interrupted", return_value=False), \
+         patch("gateway.channel_directory.resolve_channel_name", side_effect=AssertionError("raw UUID should not resolve via directory")), \
+         patch("model_tools._run_async", side_effect=_run_async_immediately), \
+         patch("tools.send_message_tool._send_to_platform", new=AsyncMock(return_value={"success": True})) as send_mock, \
+         patch("gateway.mirror.mirror_to_session", return_value=True):
+        result = json.loads(
+            send_message_tool(
+                {
+                    "action": "send",
+                    "target": f"buzz:{channel_id}",
+                    "message": "hello group",
+                }
+            )
+        )
+
+    assert result["success"] is True
+    assert "note" not in result
+    send_mock.assert_awaited_once_with(
+        buzz_platform,
+        buzz_cfg,
+        channel_id,
+        "hello group",
+        thread_id=None,
+        media_files=[],
+        force_document=False,
+    )
+
+
+def test_photon_e164_target_is_explicit() -> None:
+    chat_id, thread_id, is_explicit = _parse_target_ref("photon", "+15551234567")
+
+    assert chat_id == "+15551234567"
+    assert thread_id is None
+    assert is_explicit is True
+
+
+def test_e164_target_still_requires_phone_platform() -> None:
+    assert _parse_target_ref("matrix", "+15551234567")[2] is False
+
+
+def test_send_message_routes_whatsapp_group_jid_without_home_fallback() -> None:
+    whatsapp_cfg = SimpleNamespace(enabled=True, token=None, extra={"api_url": "http://bridge"})
+    config = SimpleNamespace(
+        platforms={Platform.WHATSAPP: whatsapp_cfg},
+        get_home_channel=lambda _platform: SimpleNamespace(chat_id="15551234567@s.whatsapp.net"),
+    )
+
+    with patch("gateway.config.load_gateway_config", return_value=config), \
+         patch("tools.interrupt.is_interrupted", return_value=False), \
+         patch("gateway.channel_directory.resolve_channel_name", side_effect=AssertionError("raw JID should not resolve via directory")), \
+         patch("model_tools._run_async", side_effect=_run_async_immediately), \
+         patch("tools.send_message_tool._send_to_platform", new=AsyncMock(return_value={"success": True})) as send_mock, \
+         patch("gateway.mirror.mirror_to_session", return_value=True):
+        result = json.loads(
+            send_message_tool(
+                {
+                    "action": "send",
+                    "target": "whatsapp:120363408391911677@g.us",
+                    "message": "hello group",
+                }
+            )
+        )
+
+    assert result["success"] is True
+    assert "note" not in result
+    send_mock.assert_awaited_once_with(
+        Platform.WHATSAPP,
+        whatsapp_cfg,
+        "120363408391911677@g.us",
+        "hello group",
+        thread_id=None,
+        media_files=[],
+        force_document=False,
+    )
+
+
+def test_resolved_opaque_plugin_target_uses_directory_id() -> None:
+    from gateway.platform_registry import PlatformEntry, platform_registry
+
+    platform_name = "opaque-resolved-test"
+    entry = PlatformEntry(
+        name=platform_name,
+        label="Opaque resolved test",
+        adapter_factory=lambda cfg: None,
+        check_fn=lambda: True,
+    )
+    platform_registry.register(entry)
+    platform = Platform(platform_name)
+    pconfig = SimpleNamespace(enabled=True, token=None, extra={})
+    config = SimpleNamespace(
+        platforms={platform: pconfig},
+        get_home_channel=lambda _platform: None,
+    )
+    try:
+        with patch("gateway.config.load_gateway_config", return_value=config), \
+             patch("tools.interrupt.is_interrupted", return_value=False), \
+             patch(
+                 "gateway.channel_directory.resolve_channel_name",
+                 return_value="opaque:directory-id",
+             ), \
+             patch("model_tools._run_async", side_effect=_run_async_immediately), \
+             patch(
+                 "tools.send_message_tool._send_to_platform",
+                 new=AsyncMock(return_value={"success": True}),
+             ) as send_mock, \
+             patch("gateway.mirror.mirror_to_session", return_value=True):
+            result = json.loads(
+                send_message_tool(
+                    {
+                        "action": "send",
+                        "target": f"{platform_name}:Friendly name",
+                        "message": "hello",
+                    }
+                )
+            )
+    finally:
+        platform_registry.unregister(platform_name)
+
+    assert result["success"] is True
+    send_mock.assert_awaited_once_with(
+        platform,
+        pconfig,
+        "opaque:directory-id",
+        "hello",
+        thread_id=None,
+        media_files=[],
+        force_document=False,
+    )
+
+
+def test_unresolved_plugin_target_requires_explicit_parser() -> None:
+    from gateway.platform_registry import PlatformEntry, platform_registry
+
+    platform_name = "opaque-verbatim-test"
+    entry = PlatformEntry(
+        name=platform_name,
+        label="Opaque verbatim test",
+        adapter_factory=lambda cfg: None,
+        check_fn=lambda: True,
+    )
+    platform_registry.register(entry)
+    platform = Platform(platform_name)
+    # Simulate a fresh `hermes send` process: the dynamic Platform member
+    # is known from config, but plugin discovery has not registered its
+    # adapter entry yet.
+    platform_registry.unregister(platform_name)
+    pconfig = SimpleNamespace(enabled=True, token=None, extra={})
+    config = SimpleNamespace(
+        platforms={platform: pconfig},
+        get_home_channel=lambda _platform: None,
+    )
+    try:
+        with patch("gateway.config.load_gateway_config", return_value=config), \
+             patch("tools.interrupt.is_interrupted", return_value=False), \
+             patch(
+                 "gateway.channel_directory.resolve_channel_name",
+                 return_value=None,
+             ), \
+             patch(
+                 "hermes_cli.plugins.discover_plugins",
+                 side_effect=lambda: platform_registry.register(entry),
+             ) as discover_mock, \
+             patch("model_tools._run_async", side_effect=_run_async_immediately), \
+             patch(
+                 "tools.send_message_tool._send_to_platform",
+                 new=AsyncMock(return_value={"success": True}),
+             ) as send_mock, \
+             patch("gateway.mirror.mirror_to_session", return_value=True):
+            result = json.loads(
+                send_message_tool(
+                    {
+                        "action": "send",
+                        "target": f"{platform_name}:dm:panyaozhen",
+                        "message": "hello",
+                    }
+                )
+            )
+    finally:
+        platform_registry.unregister(platform_name)
+
+    assert result == {
+        "error": f"Could not resolve 'dm:panyaozhen' on {platform_name}. "
+        "The plugin parser did not recognize it and no channel-directory entry matched."
+    }
+    discover_mock.assert_called_once_with()
+    send_mock.assert_not_awaited()
+
+
+def test_unresolved_builtin_target_keeps_directory_error() -> None:
+    telegram_cfg = SimpleNamespace(enabled=True, token="***", extra={})
+    config = SimpleNamespace(
+        platforms={Platform.TELEGRAM: telegram_cfg},
+        get_home_channel=lambda _platform: None,
+    )
+
+    with patch("gateway.config.load_gateway_config", return_value=config), \
+         patch("gateway.channel_directory.resolve_channel_name", return_value=None), \
+         patch(
+             "tools.send_message_tool._send_to_platform",
+             new=AsyncMock(return_value={"success": True}),
+         ) as send_mock:
+        result = json.loads(
+            send_message_tool(
+                {
+                    "action": "send",
+                    "target": "telegram:missing-room",
+                    "message": "hello",
+                }
+            )
+        )
+
+    assert result == {
+        "error": "Could not resolve 'missing-room' on telegram. "
+        "Use send_message(action='list') to see available targets."
+    }
+    send_mock.assert_not_awaited()
+
+
+
+def test_unresolved_builtin_target_passes_through_when_requested() -> None:
+    """Cron and react keep the old pass-through behavior for unresolved
+    built-in targets: with no model in the loop to react to an error, the
+    raw id must reach the adapter, as it did before resolve_send_target
+    took over these callers."""
+    from tools.send_message_tool import resolve_send_target
+
+    with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
+        chat_id, thread_id, error = resolve_send_target(
+            "telegram", "ops-room", pass_unresolved_references=True
+        )
+
+    assert error is None
+    assert chat_id == "ops-room"
+    assert thread_id is None
+
+
+def test_unresolved_builtin_target_still_errors_for_the_model_tool() -> None:
+    """The model-facing default stays strict: unresolved targets error with a hint."""
+    from tools.send_message_tool import resolve_send_target
+
+    with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
+        chat_id, _thread_id, error = resolve_send_target("telegram", "ops-room")
+
+    assert chat_id is None
+    assert error is not None
+
+
+def test_photon_group_guid_passes_through_when_requested() -> None:
+    """The reported regression case: a photon group GUID matches no parser
+    pattern (only DM GUIDs have an explicit rule) and no directory entry.
+    Photon registers as a parser-less plugin platform, so the pass-through
+    applies once platforms are prepared."""
+    from tools.send_message_tool import (
+        prepare_send_message_platforms,
+        resolve_send_target,
+    )
+
+    prepare_send_message_platforms()
+    with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
+        chat_id, thread_id, error = resolve_send_target(
+            "photon", "iMessage;+;chat527148912345", pass_unresolved_references=True
+        )
+
+    assert error is None
+    assert chat_id == "iMessage;+;chat527148912345"
+    assert thread_id is None
+
+
+def test_parserless_plugin_target_passes_through_when_requested() -> None:
+    """A plugin platform that declares no parser has no explicit syntax at
+    all, so passing the raw id through is the only way cron can target it."""
+    from gateway.platform_registry import PlatformEntry, platform_registry
+    from tools.send_message_tool import resolve_send_target
+
+    platform_name = "opaque-cron-fallback-test"
+    entry = PlatformEntry(
+        name=platform_name,
+        label="Opaque cron fallback test",
+        adapter_factory=lambda cfg: None,
+        check_fn=lambda: True,
+    )
+    platform_registry.register(entry)
+    try:
+        with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
+            chat_id, thread_id, error = resolve_send_target(
+                platform_name, "dm:panyaozhen", pass_unresolved_references=True
+            )
+    finally:
+        platform_registry.unregister(platform_name)
+
+    assert error is None
+    assert chat_id == "dm:panyaozhen"
+    assert thread_id is None
+
+
+def test_plugin_parser_stays_authoritative_despite_fallback() -> None:
+    """A plugin that DOES declare a parser stays strict for every caller:
+    its parser is the authority on native syntax, so an unrecognized
+    target errors even with pass_unresolved_references."""
+    from gateway.platform_registry import PlatformEntry, platform_registry
+    from tools.send_message_tool import resolve_send_target
+
+    platform_name = "opaque-parser-strict-test"
+    entry = PlatformEntry(
+        name=platform_name,
+        label="Opaque parser strict test",
+        adapter_factory=lambda cfg: None,
+        check_fn=lambda: True,
+        parse_target_ref_fn=lambda ref: None,
+    )
+    platform_registry.register(entry)
+    try:
+        with patch("gateway.channel_directory.resolve_channel_name", return_value=None):
+            chat_id, _thread_id, error = resolve_send_target(
+                platform_name, "dm:panyaozhen", pass_unresolved_references=True
+            )
+    finally:
+        platform_registry.unregister(platform_name)
+
+    assert chat_id is None
+    assert error is not None