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

tests/acp_adapter/test_acp_commands.py

@@ -0,0 +1,169 @@
+import sys
+from types import ModuleType, SimpleNamespace
+
+import pytest
+from acp.schema import TextContentBlock
+
+from acp_adapter.server import HermesACPAgent
+from acp_adapter.session import SessionManager
+
+
+class FakeAgent:
+    def __init__(self):
+        self.model = "fake-model"
+        self.provider = "fake-provider"
+        self.enabled_toolsets = ["hermes-acp"]
+        self.disabled_toolsets = []
+        self.tools = []
+        self.valid_tool_names = set()
+        self._supports_active_turn_redirect = True
+        self.steers = []
+        self.redirects = []
+        self.runs = []
+
+    def steer(self, text):
+        self.steers.append(text)
+        return True
+
+    def redirect(self, text):
+        self.redirects.append(text)
+        return True
+
+    def run_conversation(self, *, user_message, conversation_history, task_id, **kwargs):
+        self.runs.append(user_message)
+        messages = list(conversation_history or [])
+        messages.append({"role": "user", "content": user_message})
+        final = f"ran: {user_message}"
+        messages.append({"role": "assistant", "content": final})
+        return {"final_response": final, "messages": messages}
+
+
+class CaptureConn:
+    def __init__(self):
+        self.updates = []
+
+    async def session_update(self, *args, **kwargs):
+        if kwargs:
+            self.updates.append((kwargs.get("session_id"), kwargs.get("update")))
+        else:
+            self.updates.append((args[0], args[1]))
+
+    async def request_permission(self, *args, **kwargs):
+        return SimpleNamespace(outcome="allow")
+
+
+class NoopDb:
+    def get_session(self, *_args, **_kwargs):
+        return None
+
+    def create_session(self, *_args, **_kwargs):
+        return None
+
+    def update_session(self, *_args, **_kwargs):
+        return None
+
+
+def make_agent_and_state():
+    fake = FakeAgent()
+    manager = SessionManager(agent_factory=lambda **kwargs: fake, db=NoopDb())
+    acp_agent = HermesACPAgent(session_manager=manager)
+    state = manager.create_session(cwd=".")
+    conn = CaptureConn()
+    acp_agent.on_connect(conn)
+    return acp_agent, state, fake, conn
+
+
+def test_acp_real_agent_gets_session_db_for_recall(monkeypatch):
+    """ACP sessions persist to SessionDB; recall must receive the same DB handle."""
+    captured = {}
+    sentinel_db = NoopDb()
+
+    class CapturingAgent(FakeAgent):
+        def __init__(self, **kwargs):
+            super().__init__()
+            captured.update(kwargs)
+
+    def mod(name, **attrs):
+        module = ModuleType(name)
+        for key, value in attrs.items():
+            setattr(module, key, value)
+        return module
+
+    monkeypatch.setitem(sys.modules, "run_agent", mod("run_agent", AIAgent=CapturingAgent))
+    monkeypatch.setitem(
+        sys.modules,
+        "hermes_cli.config",
+        mod("hermes_cli.config", load_config=lambda: {"model": {"default": "m", "provider": "p"}}),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "hermes_cli.runtime_provider",
+        mod(
+            "hermes_cli.runtime_provider",
+            resolve_runtime_provider=lambda **_kwargs: {
+                "provider": "p",
+                "api_mode": "chat_completions",
+                "base_url": "u",
+                "api_key": "k",
+                "command": None,
+                "args": [],
+            },
+        ),
+    )
+
+    manager = SessionManager(db=sentinel_db)
+    agent = manager._make_agent(session_id="acp-session", cwd=".")
+
+    assert isinstance(agent, CapturingAgent)
+    assert captured["session_db"] is sentinel_db
+    assert captured["platform"] == "acp"
+    assert captured["session_id"] == "acp-session"
+
+
+@pytest.mark.asyncio
+async def test_acp_steer_slash_command_injects_into_running_agent():
+    acp_agent, state, fake, _conn = make_agent_and_state()
+    state.is_running = True
+
+    response = await acp_agent.prompt(
+        session_id=state.session_id,
+        prompt=[TextContentBlock(type="text", text="/steer prefer the simpler fix")],
+    )
+
+    assert response.stop_reason == "end_turn"
+    assert fake.steers == ["prefer the simpler fix"]
+    assert fake.runs == []
+
+
+
+
+
+
+
+
+@pytest.mark.asyncio
+async def test_acp_cancel_publishes_hard_stop_while_holding_runtime_lock():
+    acp_agent, state, fake, _conn = make_agent_and_state()
+    state.is_running = True
+    state.current_prompt_text = "original request"
+    observed = {}
+
+    def interrupt():
+        acquired = state.runtime_lock.acquire(blocking=False)
+        observed["lock_held"] = not acquired
+        if acquired:
+            state.runtime_lock.release()
+
+    fake.interrupt = interrupt
+
+    await acp_agent.cancel(state.session_id)
+
+    assert observed["lock_held"] is True
+    assert state.cancel_event.is_set()
+    assert state.interrupted_prompt_text == "original request"
+
+
+
+
+
+

tests/acp_adapter/test_acp_images.py

@@ -0,0 +1,83 @@
+import base64
+
+import pytest
+from acp.schema import (
+    BlobResourceContents,
+    EmbeddedResourceContentBlock,
+    ImageContentBlock,
+    ResourceContentBlock,
+    TextContentBlock,
+    TextResourceContents,
+)
+
+from acp_adapter.server import HermesACPAgent, _content_blocks_to_openai_user_content
+
+
+def test_acp_image_blocks_convert_to_openai_multimodal_content():
+    content = _content_blocks_to_openai_user_content([
+        TextContentBlock(type="text", text="What is in this image?"),
+        ImageContentBlock(type="image", data="aGVsbG8=", mimeType="image/png"),
+    ])
+
+    assert content == [
+        {"type": "text", "text": "What is in this image?"},
+        {
+            "type": "image_url",
+            "image_url": {"url": "data:image/png;base64,aGVsbG8="},
+        },
+    ]
+
+
+def test_text_only_acp_blocks_stay_string_for_legacy_prompt_path():
+    content = _content_blocks_to_openai_user_content([
+        TextContentBlock(type="text", text="/help"),
+    ])
+
+    assert content == "/help"
+
+
+def test_acp_resource_link_file_is_inlined_as_text(tmp_path):
+    attached = tmp_path / "notes.md"
+    attached.write_text("# Notes\n\nAttached file body", encoding="utf-8")
+
+    content = _content_blocks_to_openai_user_content([
+        TextContentBlock(type="text", text="Please read this file"),
+        ResourceContentBlock(
+            type="resource_link",
+            name="notes.md",
+            title="Project notes",
+            uri=attached.as_uri(),
+            mimeType="text/markdown",
+        ),
+    ])
+
+    assert content == (
+        "Please read this file\n"
+        "[Attached file: Project notes (notes.md)]\n"
+        f"URI: {attached.as_uri()}\n\n"
+        "# Notes\n\nAttached file body"
+    )
+
+
+
+
+@pytest.mark.asyncio
+async def test_initialize_advertises_image_prompt_capability():
+    response = await HermesACPAgent().initialize()
+
+    assert response.agent_capabilities is not None
+    assert response.agent_capabilities.prompt_capabilities is not None
+    assert response.agent_capabilities.prompt_capabilities.image is True
+
+
+# 1x1 transparent PNG — smallest valid image payload for inlining tests.
+_ONE_PX_PNG = bytes.fromhex(
+    "89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4"
+    "890000000a49444154789c6300010000000500010d0a2db40000000049454e44ae426082"
+)
+
+
+
+
+
+

tests/acp_adapter/test_acp_logging_redaction.py

@@ -0,0 +1,41 @@
+"""ACP adapter stderr logging must go through RedactingFormatter.
+
+``_setup_logging`` clears root handlers and installs its own stderr handler;
+before the fix it used a plain ``logging.Formatter`` — zero redaction on a
+surface that logs request/response internals. See issue #77484.
+"""
+
+import logging
+
+from acp_adapter.entry import _setup_logging
+
+SECRET = "sk-proj-AbCdEf1234567890SecretValue999"
+
+
+def test_acp_stderr_handler_redacts_secrets():
+    saved_handlers = logging.getLogger().handlers[:]
+    saved_level = logging.getLogger().level
+    try:
+        _setup_logging()
+        root = logging.getLogger()
+        assert root.handlers, "ACP logging setup installed no handler"
+        handler = root.handlers[0]
+        assert isinstance(handler, logging.StreamHandler)
+        record = logging.LogRecord(
+            name="acp.test",
+            level=logging.ERROR,
+            pathname=__file__,
+            lineno=1,
+            msg="request failed: OPENROUTER_API_KEY=%s",
+            args=(SECRET,),
+            exc_info=None,
+        )
+        out = handler.format(record)
+        assert SECRET not in out
+        assert "OPENROUTER_API_KEY=" in out
+    finally:
+        root = logging.getLogger()
+        root.handlers.clear()
+        for h in saved_handlers:
+            root.addHandler(h)
+        root.setLevel(saved_level)

tests/acp_adapter/test_acp_mcp_discovery.py

@@ -0,0 +1,327 @@
+"""Behavioral regression tests for ACP background MCP discovery + late-refresh.
+
+These replace the previous AST-based test that only inspected source text.
+They verify the *behavior*: (1) a blocked discovery doesn't block startup, and
+(2) a delayed-but-reachable MCP server's tools land in the agent's snapshot
+via the automatic late-refresh, cache-safely (pre-first-turn only).
+"""
+
+from __future__ import annotations
+
+import sys
+import threading
+import time
+import types
+from contextlib import nullcontext
+from types import ModuleType, SimpleNamespace
+
+import pytest
+
+from acp_adapter.server import HermesACPAgent
+from acp_adapter.session import SessionManager, SessionState
+from hermes_cli import mcp_startup
+
+
+# ---------------------------------------------------------------------------
+# Shared helpers
+# ---------------------------------------------------------------------------
+
+
+class FakeAgent:
+    """Minimal stand-in for AIAgent with the attributes late-refresh touches."""
+
+    def __init__(self):
+        self.model = "fake-model"
+        self.provider = "fake-provider"
+        self.enabled_toolsets = ["hermes-acp"]
+        self.disabled_toolsets = []
+        self.tools = []
+        self.valid_tool_names = set()
+        self._user_turn_count = 0
+        self._api_call_count = 0
+
+
+class NoopDb:
+    def get_session(self, *_a, **_k):
+        return None
+
+    def create_session(self, *_a, **_k):
+        return None
+
+    def update_session(self, *_a, **_k):
+        return None
+
+
+def _mod(name: str, **attrs) -> ModuleType:
+    module = ModuleType(name)
+    for key, value in attrs.items():
+        setattr(module, key, value)
+    return module
+
+
+@pytest.fixture(autouse=True)
+def _reset_mcp_startup_state():
+    """Ensure each test starts with a clean discovery thread state."""
+    saved_started = mcp_startup._mcp_discovery_started
+    saved_thread = mcp_startup._mcp_discovery_thread
+    mcp_startup._mcp_discovery_started = False
+    mcp_startup._mcp_discovery_thread = None
+    yield
+    thread = mcp_startup._mcp_discovery_thread
+    if thread is not None and thread.is_alive():
+        thread.join(timeout=2.0)
+    mcp_startup._mcp_discovery_started = saved_started
+    mcp_startup._mcp_discovery_thread = saved_thread
+
+
+# ---------------------------------------------------------------------------
+# Test 1 — blocked discovery does not block startup
+# ---------------------------------------------------------------------------
+
+
+def test_acp_background_discovery_does_not_block_startup(monkeypatch):
+    """start_background_mcp_discovery must return immediately even if discovery hangs."""
+    block = threading.Event()
+
+    def _blocking_discover():
+        block.wait(timeout=5.0)
+
+    monkeypatch.setitem(
+        sys.modules,
+        "hermes_cli.config",
+        _mod(
+            "hermes_cli.config",
+            read_raw_config=lambda: {"mcp_servers": {"slow": {"url": "https://mcp.example.test"}}},
+        ),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_oauth",
+        _mod("tools.mcp_oauth", suppress_interactive_oauth=lambda: nullcontext()),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_tool",
+        _mod("tools.mcp_tool", discover_mcp_tools=_blocking_discover),
+    )
+
+    start = time.monotonic()
+    mcp_startup.start_background_mcp_discovery(
+        logger=SimpleNamespace(debug=lambda *_a, **_k: None),
+        thread_name="test-acp-discovery",
+    )
+    elapsed = time.monotonic() - start
+
+    assert elapsed < 0.2, "start_background_mcp_discovery blocked for {:.3f}s".format(elapsed)
+    assert mcp_startup._mcp_discovery_thread is not None
+    assert mcp_startup._mcp_discovery_thread.is_alive()
+    block.set()
+    mcp_startup._mcp_discovery_thread.join(timeout=2.0)
+
+
+# ---------------------------------------------------------------------------
+# Test 2 — delayed discovery lands tools via late-refresh (pre-first-turn)
+# ---------------------------------------------------------------------------
+
+
+def test_acp_late_refresh_adds_tools_when_discovery_lands_after_build(monkeypatch):
+    """A slow MCP server that finishes after agent build must still appear in tools."""
+
+    discovery_block = threading.Event()
+    discovery_done = threading.Event()
+
+    def _slow_discover():
+        discovery_block.wait(timeout=5.0)
+        discovery_done.set()
+
+    monkeypatch.setitem(
+        sys.modules,
+        "hermes_cli.config",
+        _mod(
+            "hermes_cli.config",
+            read_raw_config=lambda: {"mcp_servers": {"slow": {"url": "https://mcp.example.test"}}},
+        ),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_oauth",
+        _mod("tools.mcp_oauth", suppress_interactive_oauth=lambda: nullcontext()),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_tool",
+        _mod("tools.mcp_tool", discover_mcp_tools=_slow_discover),
+    )
+
+    mcp_startup.start_background_mcp_discovery(
+        logger=SimpleNamespace(debug=lambda *_a, **_k: None),
+        thread_name="test-acp-late",
+    )
+
+    # Build the session immediately — discovery is still in flight.
+    fake = FakeAgent()
+    manager = SessionManager(agent_factory=lambda **_k: fake, db=NoopDb())
+    acp_agent = HermesACPAgent(session_manager=manager)
+    state = manager.create_session(cwd=".")
+
+    # Discovery is blocked, so it must still be in flight.
+    assert not discovery_done.is_set(), "discovery finished too early for this test"
+
+    # Track refresh_agent_mcp_tools calls.
+    refreshed = []
+
+    def _fake_refresh(agent, **_kw):
+        agent.tools = [{"function": {"name": "mcp_slow_tool"}}]
+        agent.valid_tool_names = {"mcp_slow_tool"}
+        refreshed.append(agent)
+        return {"mcp_slow_tool"}
+
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_tool",
+        _mod("tools.mcp_tool", refresh_agent_mcp_tools=_fake_refresh),
+    )
+
+    # Trigger late-refresh.
+    acp_agent._schedule_mcp_late_refresh(state)
+
+    # Release discovery so the late-refresh daemon can proceed.
+    discovery_block.set()
+
+    # Wait for the late-refresh daemon to finish.
+    deadline = time.monotonic() + 5.0
+    while not refreshed and time.monotonic() < deadline:
+        time.sleep(0.01)
+
+    assert refreshed, "late-refresh daemon did not call refresh_agent_mcp_tools"
+    assert refreshed[0] is fake
+    assert "mcp_slow_tool" in fake.valid_tool_names
+
+
+# ---------------------------------------------------------------------------
+# Test 3 — late-refresh is cache-safe: skips after first turn
+# ---------------------------------------------------------------------------
+
+
+def test_acp_late_refresh_skips_after_first_turn(monkeypatch):
+    """Once the user has sent a message, late-refresh must NOT rebuild tools."""
+
+    discovery_block = threading.Event()
+
+    def _slow_discover():
+        discovery_block.wait(timeout=5.0)
+
+    monkeypatch.setitem(
+        sys.modules,
+        "hermes_cli.config",
+        _mod(
+            "hermes_cli.config",
+            read_raw_config=lambda: {"mcp_servers": {"slow": {"url": "https://mcp.example.test"}}},
+        ),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_oauth",
+        _mod("tools.mcp_oauth", suppress_interactive_oauth=lambda: nullcontext()),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_tool",
+        _mod("tools.mcp_tool", discover_mcp_tools=_slow_discover),
+    )
+
+    mcp_startup.start_background_mcp_discovery(
+        logger=SimpleNamespace(debug=lambda *_a, **_k: None),
+        thread_name="test-acp-cache",
+    )
+
+    fake = FakeAgent()
+    fake._api_call_count = 1  # simulate: user already sent a message
+    manager = SessionManager(agent_factory=lambda **_k: fake, db=NoopDb())
+    acp_agent = HermesACPAgent(session_manager=manager)
+    state = manager.create_session(cwd=".")
+
+    refreshed = []
+
+    def _fake_refresh(agent, **_kw):
+        refreshed.append(agent)
+        return set()
+
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_tool",
+        _mod("tools.mcp_tool", refresh_agent_mcp_tools=_fake_refresh),
+    )
+
+    acp_agent._schedule_mcp_late_refresh(state)
+
+    # Release discovery so the daemon can proceed (if it were going to).
+    discovery_block.set()
+
+    # Give the daemon time to run (if it were going to).
+    time.sleep(0.5)
+
+    assert not refreshed, "late-refresh rebuilt tools after the first turn — cache broken!"
+
+
+# ---------------------------------------------------------------------------
+# Test 4 — late-refresh is serialized with turn start: skips while running
+# ---------------------------------------------------------------------------
+
+
+def test_acp_late_refresh_skips_while_turn_running(monkeypatch):
+    """A turn in flight (state.is_running) must block the rebuild even when
+    the agent's counters still read zero — closes the guard/turn-start race."""
+
+    discovery_block = threading.Event()
+
+    def _slow_discover():
+        discovery_block.wait(timeout=5.0)
+
+    monkeypatch.setitem(
+        sys.modules,
+        "hermes_cli.config",
+        _mod(
+            "hermes_cli.config",
+            read_raw_config=lambda: {"mcp_servers": {"slow": {"url": "https://mcp.example.test"}}},
+        ),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_oauth",
+        _mod("tools.mcp_oauth", suppress_interactive_oauth=lambda: nullcontext()),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_tool",
+        _mod("tools.mcp_tool", discover_mcp_tools=_slow_discover),
+    )
+
+    mcp_startup.start_background_mcp_discovery(
+        logger=SimpleNamespace(debug=lambda *_a, **_k: None),
+        thread_name="test-acp-running",
+    )
+
+    fake = FakeAgent()  # counters are 0 — only is_running blocks the refresh
+    manager = SessionManager(agent_factory=lambda **_k: fake, db=NoopDb())
+    acp_agent = HermesACPAgent(session_manager=manager)
+    state = manager.create_session(cwd=".")
+    state.is_running = True  # simulate: first prompt dispatched concurrently
+
+    refreshed = []
+
+    def _fake_refresh(agent, **_kw):
+        refreshed.append(agent)
+        return set()
+
+    monkeypatch.setitem(
+        sys.modules,
+        "tools.mcp_tool",
+        _mod("tools.mcp_tool", refresh_agent_mcp_tools=_fake_refresh),
+    )
+
+    acp_agent._schedule_mcp_late_refresh(state)
+    discovery_block.set()
+    time.sleep(0.5)
+
+    assert not refreshed, "late-refresh rebuilt tools while a turn was running!"

tests/acp_adapter/test_detect_provider_entra.py

@@ -0,0 +1,66 @@
+"""Regression tests for ACP adapter detection under Azure Foundry Entra ID.
+
+The ACP adapter's ``detect_provider`` previously gated on
+``isinstance(api_key, str)`` and returned ``None`` for any runtime that
+returned a callable ``api_key`` — i.e. Azure Foundry with
+``auth_mode=entra_id``. Downstream, ACP would default to
+``"openrouter"`` and reject the legitimate provider in its auth handshake.
+This test pins the callable-aware fix so it never regresses.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+
+class TestDetectProviderEntra:
+    def test_callable_api_key_is_a_valid_credential(self):
+        """A runtime returning a callable ``api_key`` (Entra bearer token
+        provider) must be detected as a configured provider, not
+        ``None``."""
+        from acp_adapter import auth as _acp_auth
+
+        def _fake_runtime(**_kwargs):
+            return {
+                "provider": "azure-foundry",
+                "api_mode": "chat_completions",
+                "auth_mode": "entra_id",
+                "base_url": "https://r.openai.azure.com/openai/v1",
+                "api_key": lambda: "jwt-fresh",
+            }
+
+        with patch(
+            "hermes_cli.runtime_provider.resolve_runtime_provider",
+            side_effect=_fake_runtime,
+        ):
+            assert _acp_auth.detect_provider() == "azure-foundry"
+            assert _acp_auth.has_provider() is True
+
+    def test_string_api_key_still_works(self):
+        from acp_adapter import auth as _acp_auth
+
+        def _fake_runtime(**_kwargs):
+            return {
+                "provider": "openrouter",
+                "api_key": "sk-or-static-key",
+            }
+
+        with patch(
+            "hermes_cli.runtime_provider.resolve_runtime_provider",
+            side_effect=_fake_runtime,
+        ):
+            assert _acp_auth.detect_provider() == "openrouter"
+
+    def test_empty_string_api_key_returns_none(self):
+        from acp_adapter import auth as _acp_auth
+
+        def _fake_runtime(**_kwargs):
+            return {"provider": "openrouter", "api_key": ""}
+
+        with patch(
+            "hermes_cli.runtime_provider.resolve_runtime_provider",
+            side_effect=_fake_runtime,
+        ):
+            assert _acp_auth.detect_provider() is None
+
+