OpenJarvis 0.1.2.dev790__tar.gz → 0.1.2.dev792__tar.gz

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenJarvis
-Version: 0.1.2.dev790
+Version: 0.1.2.dev792
 Summary: OpenJarvis — modular AI assistant backend with composable intelligence primitives
 Project-URL: Homepage, https://github.com/open-jarvis/OpenJarvis
 Project-URL: Documentation, https://open-jarvis.github.io/OpenJarvis/

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "OpenJarvis"
-version = "0.1.2.dev790"
+version = "0.1.2.dev792"
 description = "OpenJarvis — modular AI assistant backend with composable intelligence primitives"
 readme = "README.md"
 # Upper bound: numpy 2.2.x (pinned transitively via datasets/pandas) ships no

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/src/openjarvis/agents/channel_agent.py

@@ -112,10 +112,15 @@ class ChannelAgent:
             friendly = (
                 f"Sorry, I ran into an error while processing your request: {exc}"
             )
+            # First positional arg is the DESTINATION (per-adapter native
+            # ID — Discord channel ID, Slack channel ID, etc.); not the
+            # channel TYPE label. The `conversation_id=` kwarg is the
+            # native message ID for reply threading (per DiscordChannel
+            # / SlackChannel / etc. send() contract — see #459).
             self._channel.send(
-                msg.channel,
+                msg.conversation_id,
                 friendly,
-                conversation_id=msg.conversation_id,
+                conversation_id=msg.message_id,
             )
             return
 
@@ -130,10 +135,11 @@ class ChannelAgent:
         else:
             reply = response_text
 
+        # Same field-mapping as the error path above (#459).
         self._channel.send(
-            msg.channel,
+            msg.conversation_id,
             reply,
-            conversation_id=msg.conversation_id,
+            conversation_id=msg.message_id,
         )
 
     # ------------------------------------------------------------------

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/src/openjarvis/channels/discord_channel.py

@@ -94,6 +94,16 @@ class DiscordChannel(BaseChannel):
         if not self._token:
             logger.warning("Cannot send: no Discord bot token")
             return False
+        # Defensive guard for #459 follow-up: an empty `channel` arg would
+        # produce /channels//messages and silently 404. Better to fail
+        # explicitly so the upstream bug (wrong field passed in) surfaces
+        # in the warning log instead of silently blackholing the reply.
+        if not channel:
+            logger.warning(
+                "Cannot send: no Discord channel destination "
+                "(caller passed empty channel id)"
+            )
+            return False
 
         try:
             import httpx

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/src/openjarvis/cli/ask.py

@@ -339,7 +339,9 @@ def _run_agent(
 
     agent_cls = AgentRegistry.get(agent_name)
 
-    # Build tools
+    # Build tools — local registry tools + MCP server tools from config
+    # (#461 — MCP tools were silently dropped because ask.py only used
+    # ToolRegistry).
     tools = []
     if tool_names:
         # Trigger tool registration
@@ -347,6 +349,26 @@ def _run_agent(
 
         tools = _build_tools(tool_names, config, engine, model_name)
 
+    # MCP tools from config.tools.mcp.servers. Loaded regardless of
+    # tool_names — if the caller passed --tools, the loader filters MCP
+    # tools to those names; otherwise every MCP tool is included.
+    from openjarvis.mcp.loader import load_mcp_tools_from_config
+
+    mcp_tools, mcp_clients = load_mcp_tools_from_config(
+        config.tools.mcp,
+        allowed_names=set(tool_names) if tool_names else None,
+    )
+    if mcp_tools:
+        # Dedup against registry tools by spec.name — first occurrence wins
+        # so a registry tool always takes precedence over an MCP tool with
+        # the same name (avoids the "two tools with the same name" footgun
+        # the verdict flagged).
+        existing = {t.spec.name for t in tools}
+        for t in mcp_tools:
+            if t.spec.name not in existing:
+                tools.append(t)
+                existing.add(t.spec.name)
+
     # Build agent with appropriate kwargs
     agent_kwargs = {
         "bus": bus,
@@ -378,6 +400,12 @@ def _run_agent(
         )
 
     agent = agent_cls(engine, model_name, **agent_kwargs)
+    # Hold MCP transports alive for the agent's lifetime — without this
+    # reference they'd be garbage-collected when this function returns
+    # and the underlying HTTP connections would close mid-execution (#461
+    # adversarial review caught this).
+    if mcp_clients:
+        agent._mcp_clients = mcp_clients
     ctx = AgentContext()
 
     # Inject memory context into conversation if available

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/src/openjarvis/cli/serve.py

@@ -188,6 +188,11 @@ def serve(
                 if sec.capability_policy is not None:
                     agent_kwargs["capability_policy"] = sec.capability_policy
 
+                # MCP transports persisted on the agent at the bottom of
+                # this block — initialise here so the reference is valid
+                # even when accepts_tools is False (#461).
+                mcp_clients: list = []
+
                 # Load tools for agents that support them
                 if getattr(agent_cls, "accepts_tools", False):
                     import openjarvis.tools  # noqa: F401  # trigger registration
@@ -221,6 +226,22 @@ def serve(
                             tools.append(tool_cls())
                         elif isinstance(tool_cls, BaseTool):
                             tools.append(tool_cls)
+
+                    # MCP server tools from config.tools.mcp.servers
+                    # (#461 — these were silently dropped).
+                    from openjarvis.mcp.loader import load_mcp_tools_from_config
+
+                    mcp_tools, mcp_clients = load_mcp_tools_from_config(
+                        config.tools.mcp,
+                        allowed_names=allowed if configured else None,
+                    )
+                    if mcp_tools:
+                        existing = {t.spec.name for t in tools}
+                        for t in mcp_tools:
+                            if t.spec.name not in existing:
+                                tools.append(t)
+                                existing.add(t.spec.name)
+
                     if tools:
                         agent_kwargs["tools"] = tools
 
@@ -228,6 +249,10 @@ def serve(
                     agent_kwargs["max_turns"] = config.agent.max_turns
 
                 agent = agent_cls(engine, model_name, **agent_kwargs)
+                # Pin MCP transports to the agent's lifetime so HTTP
+                # connections don't close mid-request (#461).
+                if mcp_clients:
+                    agent._mcp_clients = mcp_clients
         except Exception as exc:
             import traceback
 
@@ -260,6 +285,10 @@ def serve(
         channel_agent = config.channel.default_agent or agent_key or "simple"
 
         _channel_tools: list = []
+        # MCP transports persisted at function scope (= server-process
+        # lifetime); see the comment near the channel-MCP-load block
+        # below. Initialise here so it's always bound. #461.
+        _channel_mcp_clients: list = []
         if channel_agent:
             try:
                 import openjarvis.agents
@@ -298,8 +327,30 @@ def serve(
                                 _channel_tools.append(_tcls())
                             elif isinstance(_tcls, BaseTool):
                                 _channel_tools.append(_tcls)
+
+                        # MCP tools for the channel agent too (#461).
+                        from openjarvis.mcp.loader import (
+                            load_mcp_tools_from_config,
+                        )
+
+                        _ch_mcp_tools, _ch_mcp_clients = load_mcp_tools_from_config(
+                            config.tools.mcp,
+                            allowed_names=_allowed if configured else None,
+                        )
+                        if _ch_mcp_tools:
+                            _existing = {t.spec.name for t in _channel_tools}
+                            for t in _ch_mcp_tools:
+                                if t.spec.name not in _existing:
+                                    _channel_tools.append(t)
+                                    _existing.add(t.spec.name)
+                        # Hold a reference at module / function scope —
+                        # the channel agent is constructed inside
+                        # JarvisSystem below; we extend its lifetime by
+                        # keeping the list bound here.
+                        _channel_mcp_clients = _ch_mcp_clients
             except Exception as exc:
                 logger.warning("Channel tools failed to load: %s", exc)
+                _channel_mcp_clients = []
 
         _wire_system = JarvisSystem(
             config=config,

openjarvis-0.1.2.dev792/src/openjarvis/mcp/loader.py

@@ -0,0 +1,133 @@
+"""Shared helper for loading MCP server tools from a TOML config blob.
+
+Used by ``cli/ask.py``, ``cli/serve.py``, ``system/builder.py`` and
+``server/agent_manager_routes.py`` so each call site doesn't reimplement
+the server-config → transport → client → discovered-tools pipeline.
+
+The returned tuple of ``(tools, clients)`` is load-bearing: the caller
+MUST hold a reference to ``clients`` for as long as the tools are used,
+otherwise the MCP transport sessions get garbage-collected and the
+underlying HTTP connections close mid-execution (see #461 adversarial
+review). The recommended pattern is to stash the client list on the
+agent so they share its lifetime:
+
+    tools, mcp_clients = load_mcp_tools_from_config(config.tools.mcp)
+    agent = AgentCls(tools=tools, ...)
+    agent._mcp_clients = mcp_clients   # keep transports alive
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from openjarvis.core.types import ToolSpec  # noqa: F401
+    from openjarvis.mcp.client import MCPClient
+    from openjarvis.tools._stubs import BaseTool
+
+logger = logging.getLogger(__name__)
+
+
+def load_mcp_tools_from_config(
+    mcp_cfg: Any,
+    *,
+    allowed_names: Optional[set[str]] = None,
+) -> tuple[list["BaseTool"], list["MCPClient"]]:
+    """Load tools from every server in ``mcp_cfg.servers``.
+
+    Returns ``(tools, clients)``. ``clients`` is the list of live
+    ``MCPClient`` instances — keep a reference or the transports get
+    GC'd. Failures in any single server are logged and that server is
+    skipped; the rest are returned as a best-effort batch.
+
+    ``allowed_names`` is an outer filter applied after each server's
+    own include/exclude filter. Pass the caller's `--tools`/`enabled`
+    list to honour CLI scoping; pass ``None`` to take every tool.
+
+    Returns ``([], [])`` when mcp is disabled or no servers are
+    configured — no exception, no warning.
+    """
+    # ``enabled`` and ``servers`` come from openjarvis.core.config's
+    # MCPConfig dataclass; accept duck-typed equivalents for tests.
+    enabled = getattr(mcp_cfg, "enabled", False)
+    servers_blob = getattr(mcp_cfg, "servers", None)
+    if not enabled or not servers_blob:
+        return [], []
+
+    try:
+        server_list = (
+            json.loads(servers_blob) if isinstance(servers_blob, str) else servers_blob
+        )
+    except (json.JSONDecodeError, TypeError) as exc:
+        logger.warning("Failed to parse MCP servers config: %s", exc)
+        return [], []
+    if not isinstance(server_list, list):
+        logger.warning(
+            "MCP servers config is not a list (got %r) — skipping MCP discovery",
+            type(server_list).__name__,
+        )
+        return [], []
+
+    # Imported lazily so that `openjarvis.mcp.loader` can be imported
+    # cheaply from CLI startup paths without dragging in the heavy MCP
+    # client stack until something actually wants to discover tools.
+    from openjarvis.mcp.client import MCPClient
+    from openjarvis.mcp.transport import StdioTransport, StreamableHTTPTransport
+    from openjarvis.tools.mcp_adapter import MCPToolProvider
+
+    tools: list["BaseTool"] = []
+    clients: list["MCPClient"] = []
+
+    for server_cfg in server_list:
+        try:
+            cfg = (
+                json.loads(server_cfg) if isinstance(server_cfg, str) else server_cfg
+            )
+            name = cfg.get("name", "<unnamed>")
+            url = cfg.get("url")
+            token = cfg.get("token")
+            command = cfg.get("command", "")
+            args = cfg.get("args", [])
+
+            if url:
+                transport = StreamableHTTPTransport(url=url, token=token)
+            elif command:
+                transport = StdioTransport(command=[command] + args)
+            else:
+                logger.warning(
+                    "MCP server '%s' has neither 'url' nor 'command' — skipping",
+                    name,
+                )
+                continue
+
+            client = MCPClient(transport)
+            client.initialize()
+            clients.append(client)
+
+            provider = MCPToolProvider(client)
+            discovered = provider.discover()
+
+            include_tools = set(cfg.get("include_tools", []))
+            exclude_tools = set(cfg.get("exclude_tools", []))
+            if include_tools:
+                discovered = [t for t in discovered if t.spec.name in include_tools]
+            if exclude_tools:
+                discovered = [t for t in discovered if t.spec.name not in exclude_tools]
+            if allowed_names:
+                discovered = [t for t in discovered if t.spec.name in allowed_names]
+
+            tools.extend(discovered)
+            logger.info(
+                "Discovered %d MCP tools from server '%s'", len(discovered), name
+            )
+        except Exception as exc:  # per-server isolation
+            logger.warning(
+                "Failed to discover MCP tools from '%s': %s",
+                cfg.get("name", "<unnamed>") if "cfg" in locals() else "<unparsed>",
+                exc,
+            )
+            continue
+
+    return tools, clients

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/src/openjarvis/mcp/transport.py

@@ -122,12 +122,14 @@ class StreamableHTTPTransport(MCPTransport):
         self,
         url: str,
         *,
+        token: Optional[str] = None,
         connect_timeout: float = 10.0,
         request_timeout: float = 60.0,
     ) -> None:
         import httpx
 
         self._url = url
+        self._token = token
         self._session_id: Optional[str] = None
         self._client = httpx.Client(
             timeout=httpx.Timeout(
@@ -146,11 +148,21 @@ class StreamableHTTPTransport(MCPTransport):
         return f"{parsed.scheme}://{parsed.netloc}"
 
     def _build_headers(self) -> dict:
-        """Build common request headers."""
+        """Build common request headers.
+
+        Sends ``Authorization: Bearer <token>`` when the transport was
+        constructed with a token (#461) — required by authenticated MCP
+        servers such as Home Assistant's. Falsy tokens (None / empty
+        string) deliberately do NOT send the header, matching the
+        upstream MCP spec and the cfg.get("token") plumbing in the
+        builder.
+        """
         headers = {
             "Content-Type": "application/json",
             "Accept": "application/json, text/event-stream",
         }
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
         if self._session_id is not None:
             headers["Mcp-Session-Id"] = self._session_id
         return headers

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/src/openjarvis/server/agent_manager_routes.py

@@ -687,12 +687,14 @@ def _get_mcp_tools(app_state: Any) -> Tuple[List[Dict[str, Any]], Dict[str, Any]
         cfg = _json.loads(server_cfg) if isinstance(server_cfg, str) else server_cfg
         name = cfg.get("name", "<unnamed>")
         url = cfg.get("url")
+        # Bearer token from config — mirrors the builder.py fix for #461.
+        token = cfg.get("token")
         command = cfg.get("command", "")
         args = cfg.get("args", [])
 
         try:
             if url:
-                transport = StreamableHTTPTransport(url=url)
+                transport = StreamableHTTPTransport(url=url, token=token)
             elif command:
                 transport = StdioTransport(command=[command] + args)
             else:

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/src/openjarvis/system/builder.py

@@ -584,11 +584,14 @@ class SystemBuilder:
         cfg = json.loads(server_cfg) if isinstance(server_cfg, str) else server_cfg
         name = cfg.get("name", "<unnamed>")
         url = cfg.get("url")
+        # Bearer token from config — needed by authenticated MCP servers
+        # like Home Assistant. None / empty string skips the header. #461.
+        token = cfg.get("token")
         command = cfg.get("command", "")
         args = cfg.get("args", [])
 
         if url:
-            transport = StreamableHTTPTransport(url=url)
+            transport = StreamableHTTPTransport(url=url, token=token)
         elif command:
             transport = StdioTransport(command=[command] + args)
         else:

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/tests/agents/test_channel_agent.py

@@ -134,12 +134,16 @@ def _make_msg(
     channel: str = "fake",
     sender: str = "user1",
     session_id: str = "sess-001",
+    conversation_id: str = "",
+    message_id: str = "",
 ) -> ChannelMessage:
     return ChannelMessage(
         channel=channel,
         sender=sender,
         content=content,
         session_id=session_id,
+        conversation_id=conversation_id,
+        message_id=message_id,
     )
 
 
@@ -251,3 +255,64 @@ class TestChannelAgent:
         assert len(channel._sent) == 1
         sent_content = channel._sent[0]["content"]
         assert "openjarvis://research/" in sent_content
+
+    def test_reply_uses_conversation_id_as_destination_not_channel_type(self):
+        """Regression for #459 — Discord (and every per-adapter native API)
+        wants the per-channel destination ID, not the channel TYPE label.
+
+        Pre-fix:
+          self._channel.send(msg.channel, ...)        # "discord" → 404
+          conversation_id=msg.conversation_id          # channel-id used as msg-ref-id
+
+        Post-fix:
+          self._channel.send(msg.conversation_id, ...) # numeric channel id
+          conversation_id=msg.message_id               # the message being replied to
+        """
+        channel = FakeChannel()
+        agent = _make_agent("hi back")
+        ca = ChannelAgent(channel, agent)
+
+        # The exact ChannelMessage shape DiscordChannel actually produces:
+        # channel = "discord" (TYPE label), conversation_id = numeric Discord
+        # channel id, message_id = numeric Discord message id.
+        msg = _make_msg(
+            content="hello",
+            channel="discord",
+            conversation_id="987654321098765432",
+            message_id="111122223333444455",
+        )
+        channel.simulate_message(msg)
+        ca.shutdown()
+
+        assert len(channel._sent) == 1
+        sent = channel._sent[0]
+        # The destination must be the numeric channel id, not the TYPE label.
+        assert sent["channel"] == "987654321098765432"
+        assert sent["channel"] != "discord"
+        # The conversation_id kwarg must carry the message id (for reply
+        # threading), not the channel id.
+        assert sent["conversation_id"] == "111122223333444455"
+
+    def test_error_path_also_uses_conversation_id_as_destination(self):
+        """The except-clause friendly-error path has the same field-mapping
+        bug as the success path (channel_agent.py:115-119). Verify both
+        sites are fixed."""
+        channel = FakeChannel()
+        agent = MagicMock()
+        agent.run.side_effect = RuntimeError("model unavailable")
+        ca = ChannelAgent(channel, agent)
+
+        msg = _make_msg(
+            content="hello",
+            channel="discord",
+            conversation_id="987654321098765432",
+            message_id="111122223333444455",
+        )
+        channel.simulate_message(msg)
+        ca.shutdown()
+
+        assert len(channel._sent) == 1
+        sent = channel._sent[0]
+        assert sent["channel"] == "987654321098765432"
+        assert sent["conversation_id"] == "111122223333444455"
+        assert "Sorry" in sent["content"]

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/tests/channels/test_discord_channel.py

@@ -77,6 +77,17 @@ class TestSend:
             payload = mock_post.call_args[1]["json"]
             assert payload["message_reference"] == {"message_id": "msg-123"}
 
+    def test_send_refuses_empty_channel(self):
+        """Defensive guard for #459 follow-up: an empty `channel` arg
+        would build /channels//messages and silently 404. We refuse
+        fast so the upstream bug surfaces in the log instead of the
+        reply being blackholed."""
+        ch = DiscordChannel(bot_token="my-bot-token")
+        with patch("httpx.post") as mock_post:
+            result = ch.send("", "Hi there!")
+            assert result is False
+            mock_post.assert_not_called()
+
     def test_send_failure(self):
         ch = DiscordChannel(bot_token="my-bot-token")
 

{openjarvis-0.1.2.dev790 → openjarvis-0.1.2.dev792}/tests/mcp/test_discovery.py

@@ -53,7 +53,11 @@ class TestDiscoverHTTPServer:
         cfg = {"name": "ha-mcp", "url": "http://172.16.3.1:9583/mcp"}
         result = builder._discover_external_mcp(cfg)
 
-        mock_transport_cls.assert_called_once_with(url="http://172.16.3.1:9583/mcp")
+        # token=None is now forwarded explicitly (#461) so authenticated
+        # MCP servers can use it; missing config field → None → no header.
+        mock_transport_cls.assert_called_once_with(
+            url="http://172.16.3.1:9583/mcp", token=None
+        )
         mock_client_cls.return_value.initialize.assert_called_once()
         assert len(result) == 2
         assert result[0].spec.name == "get_entities"
@@ -192,4 +196,8 @@ class TestStringConfig:
         cfg_str = json.dumps({"name": "test", "url": "http://localhost:8080/mcp"})
         builder._discover_external_mcp(cfg_str)
 
-        mock_transport_cls.assert_called_once_with(url="http://localhost:8080/mcp")
+        # token=None is forwarded by the builder (#461) — see comment in
+        # TestDiscoverHTTPServer.test_url_config_uses_http_transport.
+        mock_transport_cls.assert_called_once_with(
+            url="http://localhost:8080/mcp", token=None
+        )