fix(canvas/test): Spinner tests use getAttribute for SVG className

SVG elements in jsdom expose className as SVGAnimatedString (an object),
not a plain string. Calling toContain() on an object produces a confusing
"expected [] to include" error. Fix: use getAttribute("class") instead.

Also adds afterEach(cleanup) for DOM isolation between tests.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

canvas/src/components/ConversationTraceModal.tsx

@@ -31,17 +31,25 @@ export function extractMessageText(body: Record<string, unknown> | null): string
     if (text) return text;
 
     // Response: result.parts[].text or result.parts[].root.text
+    // Use the first part that has a direct text field; within that part,
+    // prefer direct text over root.text. Subsequent parts' root.text fields
+    // are ignored when a direct text exists in an earlier part.
     const result = body.result as Record<string, unknown> | undefined;
     const rParts = (result?.parts || []) as Array<Record<string, unknown>>;
-    const rText = rParts
-      .map((p) => {
-        if (p.text) return p.text as string;
-        const root = p.root as Record<string, unknown> | undefined;
-        return (root?.text as string) || "";
-      })
-      .filter(Boolean)
-      .join("\n");
-    if (rText) return rText;
+    const firstPartWithText = rParts.find(
+      (p) => typeof p.text === "string" && (p.text as string) !== ""
+    );
+    if (firstPartWithText) {
+      return firstPartWithText.text as string;
+    }
+    // No direct text found; use root.text from the first part (if present).
+    const firstPart = rParts[0];
+    if (firstPart) {
+      const root = firstPart.root as Record<string, unknown> | undefined;
+      if (typeof root?.text === "string" && root.text !== "") {
+        return root.text as string;
+      }
+    }
 
     if (typeof body.result === "string") return body.result;
   } catch { /* ignore */ }

canvas/src/components/__tests__/Spinner.test.tsx

@@ -3,52 +3,56 @@
  * Tests for Spinner component.
  *
  * Covers: sm/md/lg size classes, aria-hidden, motion-safe animate-spin class.
+ *
+ * NOTE: SVG elements use SVGAnimatedString for className (not a plain string),
+ * so we use getAttribute("class") instead of className for assertions.
  */
 import React from "react";
-import { render, screen } from "@testing-library/react";
-import { describe, expect, it } from "vitest";
+import { render, cleanup } from "@testing-library/react";
+import { afterEach, describe, expect, it } from "vitest";
 import { Spinner } from "../Spinner";
 
+afterEach(cleanup);
+
+function getSvgClass(r: ReturnType<typeof render>): string {
+  const svg = r.container.querySelector("svg");
+  if (!svg) throw new Error("No SVG found");
+  return svg.getAttribute("class") ?? "";
+}
+
 describe("Spinner — size variants", () => {
   it("renders with sm size class", () => {
-    const { container } = render(<Spinner size="sm" />);
-    const svg = container.querySelector("svg");
-    expect(svg).toBeTruthy();
-    expect(svg?.className).toContain("w-3");
-    expect(svg?.className).toContain("h-3");
+    const r = render(<Spinner size="sm" />);
+    expect(getSvgClass(r)).toContain("w-3");
+    expect(getSvgClass(r)).toContain("h-3");
   });
 
   it("renders with md size class (default)", () => {
-    const { container } = render(<Spinner size="md" />);
-    const svg = container.querySelector("svg");
-    expect(svg?.className).toContain("w-4");
-    expect(svg?.className).toContain("h-4");
+    const r = render(<Spinner size="md" />);
+    expect(getSvgClass(r)).toContain("w-4");
+    expect(getSvgClass(r)).toContain("h-4");
   });
 
   it("renders with lg size class", () => {
-    const { container } = render(<Spinner size="lg" />);
-    const svg = container.querySelector("svg");
-    expect(svg?.className).toContain("w-5");
-    expect(svg?.className).toContain("h-5");
+    const r = render(<Spinner size="lg" />);
+    expect(getSvgClass(r)).toContain("w-5");
+    expect(getSvgClass(r)).toContain("h-5");
   });
 
   it("defaults to md size when no size prop given", () => {
-    const { container } = render(<Spinner />);
-    const svg = container.querySelector("svg");
-    expect(svg?.className).toContain("w-4");
-    expect(svg?.className).toContain("h-4");
+    const r = render(<Spinner />);
+    expect(getSvgClass(r)).toContain("w-4");
+    expect(getSvgClass(r)).toContain("h-4");
   });
 
   it("has aria-hidden=true so screen readers skip it", () => {
-    const { container } = render(<Spinner />);
-    const svg = container.querySelector("svg");
+    const r = render(<Spinner />);
+    const svg = r.container.querySelector("svg");
     expect(svg?.getAttribute("aria-hidden")).toBe("true");
   });
 
   it("includes the motion-safe:animate-spin class for CSS animation", () => {
-    const { container } = render(<Spinner />);
-    const svg = container.querySelector("svg");
-    expect(svg?.className).toContain("motion-safe:animate-spin");
+    expect(getSvgClass(render(<Spinner />))).toContain("motion-safe:animate-spin");
   });
 
   it("renders exactly one SVG element", () => {

workspace/plugins_registry/__init__.py

@@ -51,6 +51,22 @@ class AdaptorSource:
 
 def _load_module_from_path(module_name: str, path: Path):
     """Import a Python file by absolute path. Returns the module or None on failure."""
+    # Ensure the plugins_registry package and its submodules are importable in the
+    # fresh module namespace created by module_from_spec().  Plugin adapters
+    # (molecule-skill-*/adapters/*.py) use "from plugins_registry.builtins import ..."
+    # which requires plugins_registry and its submodules to already be in sys.modules.
+    # We import and register them before exec_module so the plugin's own
+    # from ... import statements resolve correctly.
+    import sys
+    import plugins_registry
+    sys.modules.setdefault("plugins_registry", plugins_registry)
+    for _sub in ("builtins", "protocol", "raw_drop"):
+        try:
+            sub = importlib.import_module(f"plugins_registry.{_sub}")
+            sys.modules.setdefault(f"plugins_registry.{_sub}", sub)
+        except Exception:
+            # Submodule may not exist in all versions; skip if absent.
+            pass
     spec = importlib.util.spec_from_file_location(module_name, path)
     if spec is None or spec.loader is None:
         return None

workspace/plugins_registry/test_resolve_plugin.py

@@ -0,0 +1,60 @@
+"""Tests for _load_module_from_path sys.modules injection fix (issue #296).
+
+Verifies that plugin adapters using "from plugins_registry.builtins import ..."
+can be loaded via _load_module_from_path() without ModuleNotFoundError.
+"""
+import sys
+import tempfile
+import os
+from pathlib import Path
+
+# Ensure the plugins_registry package is importable
+import plugins_registry
+
+from plugins_registry import _load_module_from_path
+
+
+def test_load_adapter_with_plugins_registry_import():
+    """Plugin adapter using 'from plugins_registry.builtins import ...' loads cleanly."""
+    # Write a temp adapter file that does the exact import from the bug report.
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".py", delete=False, dir=tempfile.gettempdir()
+    ) as f:
+        f.write("from plugins_registry.builtins import AgentskillsAdaptor as Adaptor\n")
+        f.write("assert Adaptor is not None\n")
+        adapter_path = Path(f.name)
+
+    try:
+        module = _load_module_from_path("test_adapter", adapter_path)
+        assert module is not None, "module should load without error"
+        assert hasattr(module, "Adaptor"), "module should expose Adaptor"
+    finally:
+        os.unlink(adapter_path)
+
+
+def test_load_adapter_with_full_plugins_registry_import():
+    """Plugin adapter using 'from plugins_registry import ...' loads cleanly."""
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".py", delete=False, dir=tempfile.gettempdir()
+    ) as f:
+        f.write("from plugins_registry import InstallContext, resolve\n")
+        f.write("from plugins_registry.protocol import PluginAdaptor\n")
+        f.write("assert InstallContext is not None\n")
+        f.write("assert resolve is not None\n")
+        f.write("assert PluginAdaptor is not None\n")
+        adapter_path = Path(f.name)
+
+    try:
+        module = _load_module_from_path("test_adapter_full", adapter_path)
+        assert module is not None, "module should load without error"
+        assert hasattr(module, "InstallContext"), "module should expose InstallContext"
+        assert hasattr(module, "resolve"), "module should expose resolve"
+        assert hasattr(module, "PluginAdaptor"), "module should expose PluginAdaptor"
+    finally:
+        os.unlink(adapter_path)
+
+
+if __name__ == "__main__":
+    test_load_adapter_with_plugins_registry_import()
+    test_load_adapter_with_full_plugins_registry_import()
+    print("ALL TESTS PASS")

workspace/tests/test_a2a_tools_inbox_wrappers.py

@@ -15,6 +15,7 @@ The wrappers are ~40 LOC of glue. The full delivery behavior
 """
 from __future__ import annotations
 
+import asyncio
 import json
 from unittest.mock import MagicMock, patch
 
@@ -28,22 +29,24 @@ def _require_workspace_id(monkeypatch):
     yield
 
 
+def _run(coro):
+    return asyncio.get_event_loop().run_until_complete(coro)
+
+
 # ---------------------------------------------------------------------------
 # tool_inbox_peek
 # ---------------------------------------------------------------------------
 
 
 class TestToolInboxPeek:
-    @pytest.mark.asyncio
-    async def test_returns_not_enabled_when_state_none(self):
+    def test_returns_not_enabled_when_state_none(self):
         import a2a_tools
 
         with patch("inbox.get_state", return_value=None):
-            out = await a2a_tools.tool_inbox_peek()
+            out = _run(a2a_tools.tool_inbox_peek())
         assert "not enabled" in out
 
-    @pytest.mark.asyncio
-    async def test_returns_json_array_of_messages(self):
+    def test_returns_json_array_of_messages(self):
         import a2a_tools
 
         msg1 = MagicMock()
@@ -55,21 +58,20 @@ class TestToolInboxPeek:
         fake_state.peek.return_value = [msg1, msg2]
 
         with patch("inbox.get_state", return_value=fake_state):
-            out = await a2a_tools.tool_inbox_peek(limit=5)
+            out = _run(a2a_tools.tool_inbox_peek(limit=5))
         # peek limit is forwarded
         fake_state.peek.assert_called_once_with(limit=5)
         parsed = json.loads(out)
         assert len(parsed) == 2
         assert parsed[0]["activity_id"] == "a1"
 
-    @pytest.mark.asyncio
-    async def test_non_int_limit_falls_back_to_10(self):
+    def test_non_int_limit_falls_back_to_10(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.peek.return_value = []
         with patch("inbox.get_state", return_value=fake_state):
-            await a2a_tools.tool_inbox_peek(limit="garbage")  # type: ignore[arg-type]
+            _run(a2a_tools.tool_inbox_peek(limit="garbage"))  # type: ignore[arg-type]
         fake_state.peek.assert_called_once_with(limit=10)
 
 
@@ -79,54 +81,49 @@ class TestToolInboxPeek:
 
 
 class TestToolInboxPop:
-    @pytest.mark.asyncio
-    async def test_returns_not_enabled_when_state_none(self):
+    def test_returns_not_enabled_when_state_none(self):
         import a2a_tools
 
         with patch("inbox.get_state", return_value=None):
-            out = await a2a_tools.tool_inbox_pop("act-1")
+            out = _run(a2a_tools.tool_inbox_pop("act-1"))
         assert "not enabled" in out
 
-    @pytest.mark.asyncio
-    async def test_rejects_empty_activity_id(self):
+    def test_rejects_empty_activity_id(self):
         import a2a_tools
 
         fake_state = MagicMock()
         with patch("inbox.get_state", return_value=fake_state):
-            out = await a2a_tools.tool_inbox_pop("")
+            out = _run(a2a_tools.tool_inbox_pop(""))
         assert "activity_id is required" in out
         fake_state.pop.assert_not_called()
 
-    @pytest.mark.asyncio
-    async def test_rejects_non_str_activity_id(self):
+    def test_rejects_non_str_activity_id(self):
         import a2a_tools
 
         fake_state = MagicMock()
         with patch("inbox.get_state", return_value=fake_state):
-            out = await a2a_tools.tool_inbox_pop(123)  # type: ignore[arg-type]
+            out = _run(a2a_tools.tool_inbox_pop(123))  # type: ignore[arg-type]
         assert "activity_id is required" in out
         fake_state.pop.assert_not_called()
 
-    @pytest.mark.asyncio
-    async def test_returns_removed_true_when_popped(self):
+    def test_returns_removed_true_when_popped(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.pop.return_value = MagicMock()  # truthy = something was removed
         with patch("inbox.get_state", return_value=fake_state):
-            out = await a2a_tools.tool_inbox_pop("act-7")
+            out = _run(a2a_tools.tool_inbox_pop("act-7"))
         parsed = json.loads(out)
         assert parsed == {"removed": True, "activity_id": "act-7"}
         fake_state.pop.assert_called_once_with("act-7")
 
-    @pytest.mark.asyncio
-    async def test_returns_removed_false_when_unknown(self):
+    def test_returns_removed_false_when_unknown(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.pop.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            out = await a2a_tools.tool_inbox_pop("act-missing")
+            out = _run(a2a_tools.tool_inbox_pop("act-missing"))
         parsed = json.loads(out)
         assert parsed == {"removed": False, "activity_id": "act-missing"}
 
@@ -137,28 +134,25 @@ class TestToolInboxPop:
 
 
 class TestToolWaitForMessage:
-    @pytest.mark.asyncio
-    async def test_returns_not_enabled_when_state_none(self):
+    def test_returns_not_enabled_when_state_none(self):
         import a2a_tools
 
         with patch("inbox.get_state", return_value=None):
-            out = await a2a_tools.tool_wait_for_message(timeout_secs=1.0)
+            out = _run(a2a_tools.tool_wait_for_message(timeout_secs=1.0))
         assert "not enabled" in out
 
-    @pytest.mark.asyncio
-    async def test_timeout_payload_when_no_message(self):
+    def test_timeout_payload_when_no_message(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.wait.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            out = await a2a_tools.tool_wait_for_message(timeout_secs=0.1)
+            out = _run(a2a_tools.tool_wait_for_message(timeout_secs=0.1))
         parsed = json.loads(out)
         assert parsed["timeout"] is True
         assert parsed["timeout_secs"] == 0.1
 
-    @pytest.mark.asyncio
-    async def test_returns_message_when_delivered(self):
+    def test_returns_message_when_delivered(self):
         import a2a_tools
 
         msg = MagicMock()
@@ -166,40 +160,37 @@ class TestToolWaitForMessage:
         fake_state = MagicMock()
         fake_state.wait.return_value = msg
         with patch("inbox.get_state", return_value=fake_state):
-            out = await a2a_tools.tool_wait_for_message(timeout_secs=2.0)
+            out = _run(a2a_tools.tool_wait_for_message(timeout_secs=2.0))
         parsed = json.loads(out)
         assert parsed["activity_id"] == "a-9"
 
-    @pytest.mark.asyncio
-    async def test_timeout_clamped_to_300(self):
+    def test_timeout_clamped_to_300(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.wait.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            await a2a_tools.tool_wait_for_message(timeout_secs=99999)
+            _run(a2a_tools.tool_wait_for_message(timeout_secs=99999))
         # Whatever wait was called with, it must not exceed 300
         passed = fake_state.wait.call_args.args[0]
         assert passed == 300.0
 
-    @pytest.mark.asyncio
-    async def test_timeout_clamped_to_zero_floor(self):
+    def test_timeout_clamped_to_zero_floor(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.wait.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            await a2a_tools.tool_wait_for_message(timeout_secs=-5)
+            _run(a2a_tools.tool_wait_for_message(timeout_secs=-5))
         passed = fake_state.wait.call_args.args[0]
         assert passed == 0.0
 
-    @pytest.mark.asyncio
-    async def test_non_numeric_timeout_falls_back_to_60(self):
+    def test_non_numeric_timeout_falls_back_to_60(self):
         import a2a_tools
 
         fake_state = MagicMock()
         fake_state.wait.return_value = None
         with patch("inbox.get_state", return_value=fake_state):
-            await a2a_tools.tool_wait_for_message(timeout_secs="garbage")  # type: ignore[arg-type]
+            _run(a2a_tools.tool_wait_for_message(timeout_secs="garbage"))  # type: ignore[arg-type]
         passed = fake_state.wait.call_args.args[0]
         assert passed == 60.0