[Feature Request]: Add support for MCP resources (resources/list and resources/read)

[d1r3ct]

Component

CLI

Problem statement

MCP servers expose tools and resources. Resources are more and more used to help the LLM sort out what to with the tools and the context the MCP environnement and tool usage.

While Vibe CLI correctly discover the tools, it ignores the resources section which may lead to underperformance in tool usage or in the understanding of tool's output.

Proposed solution

Add the discovery of the tools

1. Extend tools.py - Add Resource Functions

async def list_resources_http(
	url: str,
    *,
    headers: dict[str, str] | None = None,
    auth: httpx.Auth | None = None,
    startup_timeout_sec: float | None = None,
) -> list[dict[str, Any]]:
    """List all resources from an MCP server via HTTP transport."""
	...

async def read_resource_http(
	url: str,
    uri: str,
    *,
    headers: dict[str, str] | None = None,
    auth: httpx.Auth | None = None,
    startup_timeout_sec: float | None = None,
) -> list[dict[str, Any]]:
    """Read a resource from an MCP server via HTTP transport."""
	...

2. Add New DTO Classes

class _MCPResource(BaseModel):
    """MCP Resource DTO."""
    model_config = ConfigDict(from_attributes=True)
    uri: str
    name: str
    description: str | None = None
    mimeType: str

class _MCPResourceContent(BaseModel):
    """MCP Resource Content DTO."""
    model_config = ConfigDict(from_attributes=True)
    uri: str
    mimeType: str
    text: str | None = None
    data: bytes | None = None

3. Extend Registry.py

# vibe/core/tools/mcp/registry.py
# Modify MCPRegistry class

from vibe.core.tools.mcp.tools import (
    list_resources_http,
    list_resources_stdio,
    read_resource_http,
    read_resource_stdio,
    _MCPResource,
)

class MCPRegistry:
    # Add to __init__:
    def __init__(self) -> None:
        self._cache: dict[str, dict[str, type[BaseTool]]] = {}
        self._resources_cache: dict[str, dict[str, _MCPResource]] = {}  # NEW
        # ... existing code ...

    async def _discover_http(
        self, srv: MCPHttp | MCPStreamableHttp
    ) -> dict[str, type[BaseTool]] | None:
        # ... existing tool discovery code ...

        # NEW: Discover resources
        try:
            resources = await list_resources_http(
                url, headers=headers, startup_timeout_sec=srv.startup_timeout_sec
            )
            self._resources_cache[self._server_key(srv)] = {
                r["uri"]: _MCPResource(**r) for r in resources
            }
            # Create resource access tools
            for resource in resources:
                try:
                    tool_cls = create_mcp_resource_proxy_tool_class(
                        url=url,
                        resource_uri=resource["uri"],
                        alias=srv.name,
                        headers=headers,
                        startup_timeout_sec=srv.startup_timeout_sec,
                    )
                    tools[tool_cls.get_name()] = tool_cls
                except Exception as exc:
                    logger.warning(
                        "Failed to register MCP resource '%s' from %s: %r",
                        resource["uri"], url, exc
                    )
        except Exception as exc:
            logger.debug("MCP resource discovery failed for %s: %s", url, exc)
        # ... rest of existing code ...

    # Add new method for resource discovery
    async def _discover_resources_http(
        self, srv: MCPHttp | MCPStreamableHttp
    ) -> dict[str, _MCPResource] | None:
        url = (srv.url or "").strip()
        if not url:
            return None

        headers = srv.http_headers()
        try:
            resources = await list_resources_http(
                url, headers=headers, startup_timeout_sec=srv.startup_timeout_sec
            )
            return {r["uri"]: _MCPResource(**r) for r in resources}
        except Exception as exc:
            logger.warning("MCP resource discovery failed for %s: %s", url, exc)
            return None

4. Create Resource Proxy Tool Class

# vibe/core/tools/mcp/tools.py
# Add after create_mcp_stdio_proxy_tool_class

def create_mcp_resource_proxy_tool_class(
    *,
    url: str,
    resource_uri: str,
    alias: str | None = None,
    server_hint: str | None = None,
    headers: dict[str, str] | None = None,
    auth: httpx.Auth | None = None,
    startup_timeout_sec: float | None = None,
) -> type[BaseTool[_OpenArgs, MCPToolResult, BaseToolConfig, BaseToolState]]:
    """Create a tool class for reading MCP resources."""
	...

5. Add Resource Listing Tool

# vibe/core/tools/mcp/registry.py
# Add after _discover_resources_http

async def _create_resource_listing_tool(
    self, srv: MCPServer, resources: dict[str, _MCPResource]
) -> type[BaseTool] | None:
    """Create a tool for listing all resources from a server."""
	...

6. Add stdio Support

# vibe/core/tools/mcp/tools.py
# Add after the HTTP functions

async def list_resources_stdio(
    command: list[str],
    *,
    env: dict[str, str] | None = None,
    cwd: str | None = None,
    startup_timeout_sec: float | None = None,
) -> list[dict[str, Any]]:
    """List all resources from an MCP server via stdio transport."""
	...
	
async def read_resource_stdio(
    command: list[str],
    uri: str,
    *,
    env: dict[str, str] | None = None,
    cwd: str | None = None,
    startup_timeout_sec: float | None = None,
) -> list[dict[str, Any]]:
    """Read a resource from an MCP server via stdio transport."""
	...

7. Update Registry for stdio Resources

# vibe/core/tools/mcp/registry.py
# Modify _discover_stdio method

async def _discover_stdio(self, srv: MCPStdio) -> dict[str, type[BaseTool]] | None:
    cmd = srv.argv()
    if not cmd:
        logger.warning("MCP stdio server '%s' has invalid/empty command", srv.name)
        return {}

    try:
        remotes = await list_tools_stdio(
            cmd,
            env=srv.env or None,
            cwd=srv.cwd,
            startup_timeout_sec=srv.startup_timeout_sec,
        )
        # NEW: Discover resources
        resources = await list_resources_stdio(
            cmd,
            env=srv.env or None,
            cwd=srv.cwd,
            startup_timeout_sec=srv.startup_timeout_sec,
        )
        resources_dict = {r["uri"]: _MCPResource(**r) for r in resources}
        self._resources_cache[self._server_key(srv)] = resources_dict
    except Exception as exc:
        logger.warning("MCP stdio discovery failed for %r: %s", cmd, exc)
        return None

    tools: dict[str, type[BaseTool]] = {}
    for remote in remotes:
        # ... existing tool registration ...

    # NEW: Register resource access tools
    for resource in resources:
        try:
            proxy_cls = create_mcp_stdio_resource_proxy_tool_class(
                command=cmd,
                resource_uri=resource["uri"],
                alias=srv.name,
                env=srv.env or None,
                cwd=srv.cwd,
                startup_timeout_sec=srv.startup_timeout_sec,
            )
            tools[proxy_cls.get_name()] = proxy_cls
        except Exception as exc:
            logger.warning(
                "Failed to register MCP stdio resource '%s' from %r: %r",
                resource["uri"], cmd, exc
            )

    return tools

Architecture Overview

New Components:

MCP Server (supports tools + resources)
↓
Vibe MCP Integration (maps tools + resources → Vibe tools)
↓
Vibe Agent (can call both tool and resource endpoints)

Tool Naming Convention:

• Resource listing: <mcp_server_name>-mcp_list_resources
• Individual resources: <mcp_server_name>-mcp_read_resource_doc__tools__<tool_name> (auto-generated from URI)

Alternative Simpler Approach

Instead of creating one tool per resource, create two generic tools:

# vibe/core/tools/mcp/resource_tools.py (new file)

class ListResourcesTool(MCPTool):
    """List all resources from an MCP server."""
    # Implementation calls list_resources for the server

class ReadResourceTool(MCPTool):
    """Read a resource from an MCP server by URI."""
    # Takes URI as parameter

This would be easier to implement and result in only 2 new tools instead of N+1 tools.

In any case, happy to code it by myself.

Additional context

No response