Skip to content

Graph-Native Infrastructure for Context and Accountable AI Systems

fix(cli): dispatch mcp call through semantica_mcp.mcp.server (#1368)

BingEdwardc449209168f6
diff --git a/semantica/cli.py b/semantica/cli.py
index dd8c09b5..ade8ddd9 100644
--- a/semantica/cli.py
+++ b/semantica/cli.py
@@ -4764,15 +4764,10 @@ def mcp_list_tools(cli_ctx: CLIContext, local_json: bool) -> None:
cli_ctx = _require_ctx(cli_ctx)
def _action() -> None:
- try:
- from semantica_mcp.mcp.tools import __all__ as tools
- except ImportError:
- tools = [
- "extract_entities", "extract_relations", "build_graph",
- "query_graph", "get_graph_analytics", "run_reasoning",
- "record_decision", "get_decisions", "export_graph",
- "validate_shacl", "get_provenance", "embed_and_search",
- ]
+ # Same catalog the server exposes via tools/list, so `list-tools`
+ # and `mcp start` can't drift (issue #1355).
+ from semantica_mcp.mcp.tools import TOOL_DEFINITIONS
+ tools = [t["name"] for t in TOOL_DEFINITIONS]
if _is_json(cli_ctx, local_json):
_jecho({"tools": list(tools)})
else:
@@ -4805,12 +4800,15 @@ def mcp_call(cli_ctx: CLIContext, tool_name: str, args: str, local_json: bool) -
tool_args = json.loads(args)
except json.JSONDecodeError as exc:
raise click.ClickException(f"Invalid JSON in --args: {exc}") from exc
+ if not isinstance(tool_args, dict):
+ raise click.ClickException("--args must be a JSON object")
+ # Dispatch through the same server `mcp start` spawns; its session
+ # module never defined MCPSession (issue #1355).
+ from semantica_mcp.mcp.server import UnknownToolError, call_tool
try:
- from semantica_mcp.mcp.session import MCPSession
- session = MCPSession(config=cli_ctx.config.to_dict())
- result = session.call_tool(tool_name, **tool_args)
- except ImportError as exc:
- raise click.ClickException(f"MCP module not available: {exc}") from exc
+ result = call_tool(tool_name, tool_args)
+ except UnknownToolError as exc:
+ raise click.ClickException(str(exc)) from exc
if _is_json(cli_ctx, local_json):
_jecho(result if isinstance(result, (dict, list)) else {"result": str(result)})
else:
diff --git a/semantica_mcp/mcp/server.py b/semantica_mcp/mcp/server.py
index d9484df2..cd657da5 100644
--- a/semantica_mcp/mcp/server.py
+++ b/semantica_mcp/mcp/server.py
@@ -51,6 +51,27 @@ _INTERNAL_ERROR = -32603
_TOOL_INDEX: dict[str, dict] = {t["name"]: t for t in TOOL_DEFINITIONS}
+class UnknownToolError(Exception):
+ """Raised by :func:`call_tool` when the tool name is not in the catalog.
+
+ A dedicated type (rather than ``KeyError``) so callers can distinguish
+ a bad tool name from a ``KeyError`` raised inside a handler indexing a
+ required argument (e.g. ``args["category"]``).
+ """
+
+
+def call_tool(name: str, arguments: dict) -> dict:
+ """Invoke a tool in-process by name and return its raw result dict.
+
+ Shared by the JSON-RPC ``tools/call`` handler and ``semantica mcp call``
+ (issue #1355), so both expose exactly the same tool set.
+ """
+ tool = _TOOL_INDEX.get(name)
+ if tool is None:
+ raise UnknownToolError(f"Unknown tool: {name}")
+ return tool["_handler"](arguments)
+
+
# ---------------------------------------------------------------------------
# Request handlers
# ---------------------------------------------------------------------------
@@ -85,12 +106,10 @@ def _handle_tools_call(req_id: Any, params: dict) -> dict:
name = params.get("name", "")
args = params.get("arguments", {}) or {}
- tool = _TOOL_INDEX.get(name)
- if tool is None:
- return _err(req_id, _METHOD_NOT_FOUND, f"Unknown tool: {name}")
-
try:
- result = tool["_handler"](args)
+ result = call_tool(name, args)
+ except UnknownToolError as exc:
+ return _err(req_id, _METHOD_NOT_FOUND, str(exc))
except Exception as exc:
log.exception("Tool %s raised an exception", name)
# The exception's class name (e.g. "ValidationError", "TimeoutError")
diff --git a/tests/test_cli_commands.py b/tests/test_cli_commands.py
index c2b5f870..0f6cc1e8 100644
--- a/tests/test_cli_commands.py
+++ b/tests/test_cli_commands.py
@@ -2090,12 +2090,16 @@ class TestMCP:
# Table renders correctly — at minimum the column header is present
assert "Tool" in result.output or "tool" in result.output.lower()
- def test_list_tools_with_mock_shows_known_tools(self, runner, monkeypatch):
- fake_tools = _fake_module(__all__=["extract_entities", "query_graph"])
- monkeypatch.setitem(__import__("sys").modules, "semantica_mcp.mcp.tools", fake_tools)
+ def test_list_tools_reads_server_catalog(self, runner, monkeypatch):
+ """list-tools must read TOOL_DEFINITIONS (what the server serves via
+ tools/list), not the module's ``__all__`` (issue #1355)."""
+ import semantica_mcp.mcp.tools as tools_mod
+ fake = [{"name": "fake_tool_from_catalog", "description": "", "inputSchema": {},
+ "_handler": lambda a: {}}]
+ monkeypatch.setattr(tools_mod, "TOOL_DEFINITIONS", fake)
result = runner.invoke(cli_module.main, ["mcp", "list-tools"])
_ok(result)
- assert "extract_entities" in result.output
+ assert "fake_tool_from_catalog" in result.output
def test_list_tools_json(self, runner):
result = runner.invoke(cli_module.main, ["mcp", "list-tools", "--json"])
@@ -2138,14 +2142,39 @@ class TestMCP:
err = json.loads(result.stderr)
assert err["error"].startswith("Invalid JSON in --args")
- def test_call_import_error_is_clean(self, runner):
- with patch("builtins.__import__", side_effect=lambda n, *a, **k: (
- (_ for _ in ()).throw(ImportError(n))
- if n.startswith("mcp") else __import__(n, *a, **k)
- )):
- result = runner.invoke(cli_module.main, ["mcp", "call", "extract_entities"])
+ def test_call_dispatches_through_packaged_server(self, runner):
+ """Regression for issue #1355: ``mcp call`` dispatches in-process through
+ ``semantica_mcp.mcp.server`` (the server ``mcp start`` spawns) instead
+ of importing the nonexistent ``MCPSession``."""
+ result = runner.invoke(
+ cli_module.main, ["--json", "mcp", "call", "extract_entities"]
+ )
+ _ok(result)
+ # Empty args short-circuit before heavy imports; reaching the
+ # handler's own validation proves the dispatch path works.
+ assert "text is required" in result.output
+
+ def test_call_unknown_tool_fails_cleanly(self, runner):
+ result = runner.invoke(cli_module.main, ["mcp", "call", "no_such_tool"])
+ assert result.exit_code != 0
+ assert "Traceback" not in result.output
+ assert "Unknown tool" in result.output
+
+ def test_call_non_object_args_rejected(self, runner):
+ result = runner.invoke(
+ cli_module.main, ["mcp", "call", "extract_entities", "--args", "[1, 2]"]
+ )
assert result.exit_code != 0
assert "Traceback" not in result.output
+ assert "--args must be a JSON object" in result.output
+
+ def test_list_tools_json_matches_server_catalog(self, runner):
+ """The CLI catalog and the MCP server catalog must be the same list."""
+ from semantica_mcp.mcp.tools import TOOL_DEFINITIONS
+ result = runner.invoke(cli_module.main, ["mcp", "list-tools", "--json"])
+ _ok(result)
+ data = _json_output(result)
+ assert data["tools"] == [t["name"] for t in TOOL_DEFINITIONS]
# ─── services group (backward-compat wrapper) ─────────────────────────────────
diff --git a/tests/test_mcp_package_call_tool.py b/tests/test_mcp_package_call_tool.py
new file mode 100644
index 00000000..58587911
--- /dev/null
+++ b/tests/test_mcp_package_call_tool.py
@@ -0,0 +1,64 @@
+"""Tests for the shared in-process tool entry point (issue #1355).
+
+``semantica_mcp.mcp.server.call_tool`` is the dispatch used by both the
+JSON-RPC ``tools/call`` handler and the ``semantica mcp call`` CLI command,
+so the two surfaces cannot expose different tool sets.
+"""
+
+import os
+import sys
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from semantica_mcp.mcp import server
+from semantica_mcp.mcp.server import UnknownToolError, _handle_tools_call, call_tool
+
+
+class TestCallTool(unittest.TestCase):
+
+ def test_known_tool_dispatches_to_handler(self):
+ # Empty args hit extract_entities' own validation before any heavy
+ # imports, which is enough to prove dispatch reached the handler.
+ result = call_tool("extract_entities", {})
+ self.assertEqual(result["error"], "text is required")
+
+ def test_unknown_tool_raises_unknown_tool_error(self):
+ with self.assertRaises(UnknownToolError):
+ call_tool("no_such_tool", {})
+
+ def test_unknown_tool_error_is_not_a_key_error(self):
+ """A handler's own KeyError (missing required arg) must remain
+ distinguishable from an unknown tool name."""
+ self.assertFalse(issubclass(UnknownToolError, KeyError))
+
+
+class TestToolsCallDispatch(unittest.TestCase):
+
+ @staticmethod
+ def _tools_call(name, arguments):
+ return _handle_tools_call(1, {"name": name, "arguments": arguments})
+
+ def test_unknown_tool_returns_method_not_found(self):
+ response = self._tools_call("no_such_tool", {})
+ self.assertEqual(response["error"]["code"], -32601)
+ self.assertEqual(response["error"]["message"], "Unknown tool: no_such_tool")
+
+ def test_handler_key_error_is_internal_error_not_unknown_tool(self):
+ def _boom(args):
+ raise KeyError("category")
+
+ fake = {"name": "boom", "description": "", "inputSchema": {}, "_handler": _boom}
+ with patch.dict(server._TOOL_INDEX, {"boom": fake}):
+ response = self._tools_call("boom", {})
+ self.assertEqual(response["error"]["code"], -32603)
+
+ def test_known_tool_returns_result_content(self):
+ response = self._tools_call("extract_entities", {})
+ self.assertIn("content", response["result"])
+ self.assertTrue(response["result"]["isError"])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_mcp_stdio_roundtrip.py b/tests/test_mcp_stdio_roundtrip.py
index acf2bd9c..90cd3191 100644
--- a/tests/test_mcp_stdio_roundtrip.py
+++ b/tests/test_mcp_stdio_roundtrip.py
@@ -91,7 +91,7 @@ _INIT_REQUEST = _jsonrpc("initialize", 1, {
# ---------------------------------------------------------------------------
class TestMCPStdioFramingContract(unittest.TestCase):
- """Run 'python -m mcp' exactly as an MCP client would, over a real pipe.
+ """Run 'python -m semantica_mcp.mcp' exactly as an MCP client would, over a real pipe.
Each test sends a complete JSON-RPC session through stdin and asserts that
every byte on stdout is valid JSON — catching the exact failure mode from
@@ -102,7 +102,7 @@ class TestMCPStdioFramingContract(unittest.TestCase):
def _run(self, *requests: bytes) -> subprocess.CompletedProcess:
return subprocess.run(
- [sys.executable, "-m", "mcp"],
+ [sys.executable, "-m", "semantica_mcp.mcp"],
input=b"".join(requests),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,