superqode 2.5.1__tar.gz → 2.5.2__tar.gz

{superqode-2.5.1 → superqode-2.5.2}/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.5.2] - 2026-10-03
+
+### Fixed
+
+- Send configured MCP servers in the ACP protocol format, including required
+  argument, environment, and header lists, so OpenCode accepts session setup.
+- Report ACP startup failures with the failed method and validation details,
+  close the failed process, and avoid misleading connected or empty-turn messages
+  when no prompt was sent.
+
 ## [2.5.1] - 2026-10-03
 
 ### Fixed

{superqode-2.5.1 → superqode-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.5.1
+Version: 2.5.2
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.5.1 → superqode-2.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "2.5.1"
+version = "2.5.2"
 description = "The harness layer for coding agents"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-2.5.1 → superqode-2.5.2}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.5.1"
+__version__ = "2.5.2"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-2.5.1 → superqode-2.5.2}/src/superqode/acp/client.py

@@ -146,7 +146,7 @@ def _format_jsonrpc_error(error: Any) -> str:
     detail: str | None = None
     if isinstance(data, dict):
         raw = data.get("details") or data.get("message") or data.get("error")
-        detail = str(raw) if raw else None
+        detail = str(raw) if raw else json.dumps(data, ensure_ascii=False) if data else None
     elif isinstance(data, str) and data.strip():
         detail = data
 
@@ -248,6 +248,7 @@ class ACPClient:
     _usage: Dict[str, Any] = field(default_factory=dict, repr=False)
     _session_info_updates: List[dict] = field(default_factory=list, repr=False)
     _last_stop_reason: str = field(default="", repr=False)
+    last_startup_error: str = field(default="", init=False)
     _traffic_log_resolved_path: Optional[Path] = field(default=None, repr=False)
 
     # Agent-advertised capabilities from the initialize response.
@@ -305,6 +306,7 @@ class ACPClient:
 
     async def start(self) -> bool:
         """Start the ACP agent subprocess."""
+        self.last_startup_error = ""
         try:
             await self._initialize_traffic_log()
 
@@ -360,8 +362,9 @@ class ACPClient:
             return True
 
         except Exception as e:
+            self.last_startup_error = str(e) or type(e).__name__
             if self.on_thinking:
-                await self.on_thinking(f"[startup error] {e}")
+                await self.on_thinking(f"[startup error] {self.last_startup_error}")
             return False
 
     async def stop(self) -> None:
@@ -965,8 +968,10 @@ class ACPClient:
             response = await asyncio.wait_for(future, timeout=timeout or self.request_timeout)
             return response
         except asyncio.TimeoutError:
-            del self._pending_requests[request_id]
-            raise
+            self._pending_requests.pop(request_id, None)
+            raise TimeoutError(f"{method}: timed out waiting for the ACP agent") from None
+        except Exception as exc:
+            raise RuntimeError(f"{method}: {exc}") from exc
 
     async def _send_notification(self, method: str, **params) -> None:
         """Send a JSON-RPC notification (no response expected)."""

{superqode-2.5.1 → superqode-2.5.2}/src/superqode/app/mixins/agent_run.py

@@ -2745,7 +2745,9 @@ class AgentRunMixin:
                                 log.add_error,
                                 "Could not create a fresh ACP session. Retry; no prompt was sent to the old session.",
                             )
-                            return None, {}
+                            raise RuntimeError(
+                                "Could not create a fresh ACP session; no prompt was sent."
+                            )
                         self._pending_acp_fresh_target = None
                         self._call_ui(
                             log.add_info,
@@ -2779,7 +2781,10 @@ class AgentRunMixin:
                                 log.add_info,
                                 "If Grok is not signed in, run `grok login` or `grok login --device-auth`, then retry.",
                             )
-                        return None, {}
+                        detail = getattr(client, "last_startup_error", "") or "session setup failed"
+                        raise RuntimeError(
+                            f"{display_name} ACP startup failed: {detail}. No prompt was sent."
+                        )
 
                 if getattr(self, "_pending_acp_fresh_target", None) == agent_type:
                     self._pending_acp_fresh_target = None

{superqode-2.5.1 → superqode-2.5.2}/src/superqode/mcp/config.py

@@ -247,30 +247,20 @@ def get_acp_mcp_servers(config_path: Path | None = None) -> list[dict[str, Any]]
             continue
 
         config = server.config
-        server_data: dict[str, Any] = {
-            "name": server_id,
-            "transport": config.transport,
-        }
-
-        if server.description:
-            server_data["description"] = server.description
+        server_data: dict[str, Any] = {"name": server_id}
 
         if isinstance(config, MCPStdioConfig):
             server_data["command"] = config.command
-            if config.args:
-                server_data["args"] = config.args
-            if config.env:
-                server_data["env"] = config.env
-            if config.cwd:
-                server_data["cwd"] = config.cwd
-        elif isinstance(config, MCPSSEConfig):
-            server_data["url"] = config.url
-            if config.headers:
-                server_data["headers"] = config.headers
+            server_data["args"] = config.args
+            server_data["env"] = [
+                {"name": name, "value": value} for name, value in config.env.items()
+            ]
         else:
+            server_data["type"] = config.transport
             server_data["url"] = config.url
-            if config.headers:
-                server_data["headers"] = config.headers
+            server_data["headers"] = [
+                {"name": name, "value": value} for name, value in config.headers.items()
+            ]
 
         acp_servers.append(server_data)
 

{superqode-2.5.1 → superqode-2.5.2}/src/superqode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.5.1
+Version: 2.5.2
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.5.1 → superqode-2.5.2}/tests/test_acp_client.py

@@ -1252,3 +1252,29 @@ class TestToolUpdateMerging:
         assert merged["status"] == "completed"
         assert merged["title"] == "Run tests"  # from the original call
         assert merged["rawInput"] == {"command": "pytest -q"}
+
+
+@pytest.mark.asyncio
+async def test_rejected_request_identifies_method_and_validation_details(tmp_path, monkeypatch):
+    client = ACPClient(project_root=tmp_path, command="opencode acp")
+
+    async def reject(request):
+        await client._handle_message(
+            {
+                "jsonrpc": "2.0",
+                "id": request["id"],
+                "error": {
+                    "code": -32602,
+                    "message": "Invalid params",
+                    "data": {
+                        "issues": [{"path": ["mcpServers", 0, "env"], "message": "Expected array"}]
+                    },
+                },
+            }
+        )
+
+    monkeypatch.setattr(client, "_send_json", reject)
+    with pytest.raises(RuntimeError, match="session/new: Invalid params") as exc:
+        await client._call_method("session/new", cwd=str(tmp_path), mcpServers=[])
+    assert "mcpServers" in str(exc.value)
+    assert "Expected array" in str(exc.value)

{superqode-2.5.1 → superqode-2.5.2}/tests/test_mcp.py

@@ -90,9 +90,9 @@ class TestMCPConfig:
         assert get_acp_mcp_servers(config_file) == [
             {
                 "name": "fetch",
-                "transport": "stdio",
                 "command": "uvx",
                 "args": ["mcp-server-fetch"],
+                "env": [],
             }
         ]
 
@@ -360,3 +360,41 @@ class TestMCPConnection:
         assert conn.resources == []
         assert conn.prompts == []
         assert conn.error_message is None
+
+
+@pytest.mark.parametrize(
+    "server,expected",
+    [
+        ({"command": "uvx"}, {"name": "test", "command": "uvx", "args": [], "env": []}),
+        (
+            {"command": "uvx", "env": {"TEST_VAR": "value"}},
+            {
+                "name": "test",
+                "command": "uvx",
+                "args": [],
+                "env": [{"name": "TEST_VAR", "value": "value"}],
+            },
+        ),
+        (
+            {"url": "https://example.com/mcp", "headers": {"X-Test": "value"}},
+            {
+                "name": "test",
+                "type": "http",
+                "url": "https://example.com/mcp",
+                "headers": [{"name": "X-Test", "value": "value"}],
+            },
+        ),
+        (
+            {"transport": "sse", "url": "https://example.com/sse"},
+            {"name": "test", "type": "sse", "url": "https://example.com/sse", "headers": []},
+        ),
+    ],
+)
+def test_acp_mcp_servers_validate_against_protocol_schema(tmp_path, server, expected):
+    from acp.schema import NewSessionRequest
+
+    config_file = tmp_path / "mcp.json"
+    config_file.write_text(json.dumps({"mcpServers": {"test": server}}))
+    servers = get_acp_mcp_servers(config_file)
+    assert servers == [expected]
+    NewSessionRequest.model_validate({"cwd": str(tmp_path), "mcpServers": servers})

{superqode-2.5.1 → superqode-2.5.2}/tests/test_tui_smoke.py

@@ -6210,6 +6210,59 @@ def test_opencode_acp_empty_turn_retries_once_in_fresh_session(monkeypatch):
     assert "Retrying once in a fresh ACP session" in rendered
 
 
+def test_opencode_acp_startup_failure_preserves_error_without_prompt_or_retry(monkeypatch):
+    class SessionLog(FakeLog):
+        def start_agent_session(self, *args):
+            pass
+
+        def end_agent_session(self, success, text="", *args):
+            self.items.append(("end", success, text))
+
+    class FailedClient:
+        instance = None
+        last_startup_error = "session/new: Invalid params: env must be an array"
+
+        def __init__(self, **kwargs):
+            type(self).instance = self
+            self.stopped = False
+
+        def is_running(self):
+            return False
+
+        async def start(self):
+            return False
+
+        async def send_prompt(self, *_args):
+            raise AssertionError("Prompt must not be sent after startup failure")
+
+        async def reset_session(self):
+            raise AssertionError("Startup failures must not trigger the empty-turn retry")
+
+        async def stop(self):
+            self.stopped = True
+
+    app = make_app()
+    log = SessionLog()
+    app._acp_loop_runner = FakeACPLoopRunner()
+    app._call_ui = lambda fn, *args, **kwargs: fn(*args, **kwargs)
+    app._stop_thinking = lambda: None
+    app._start_stream_animation = lambda *_args: None
+    app._stop_stream_animation = lambda: None
+    monkeypatch.setattr("superqode.acp.client.ACPClient", FailedClient)
+
+    app._run_acp_jsonrpc_client(
+        "hello", "opencode", "muse-spark-1.3-contributor-free", "OpenCode", log
+    )
+
+    assert FailedClient.instance.stopped
+    assert app._acp_client is None
+    rendered = " ".join(str(item) for item in log.items)
+    assert "ACP startup failed" in rendered
+    assert FailedClient.last_startup_error in rendered
+    assert "No prompt was sent" in rendered
+    assert "empty turn" not in rendered
+
+
 def test_cleanup_on_exit_cancels_and_tears_down_local_runtime():
     app = make_app()
     pure = FakePureMode()