FastMCP Context Support in Roo Code

[socamalo]

Feature Request: FastMCP Context Support in Roo Code

Summary

Roo Code currently lacks support for FastMCP's Context functionality, which is essential for advanced MCP server capabilities including progress reporting, logging, and real-time UI updates. This feature request outlines the missing functionality and provides sample code demonstrating the differences between Cursor (which supports it) and Roo Code (which doesn't).

Current Issue

When attempting to use FastMCP Context features in Roo Code, tools that utilize ctx.report_progress(), ctx.info(), ctx.debug(), and other Context methods fail with timeout errors or are not properly handled by the Roo Code MCP client.

Sample Code Demonstrating the Problem

FastMCP Server with Context (test_context.py)

from fastmcp import FastMCP, Context
import asyncio

mcp = FastMCP(name="test_context")

@mcp.tool()
async def start_timer(ctx: Context):
    """Start a timer that updates every second using Context"""
    counter = 0
    total_seconds = 60

    await ctx.info("Timer started, will run for 1 minute")

    while counter <= total_seconds:
        # This fails in Roo Code but works in Cursor
        await ctx.report_progress(progress=counter, total=total_seconds)
        await ctx.info(f"Elapsed time: {counter} seconds")
        counter += 1
        await asyncio.sleep(1)

    await ctx.info("Timer completed!")
    return f"Timer finished, total time: {total_seconds} seconds"

if __name__ == "__main__":
    mcp.run(transport="http", port=9090, path="/mcp")

Expected Behavior vs Actual Behavior

In Cursor (Working)

1. Progress Reporting: ctx.report_progress() displays a progress bar in the UI
2. Logging: ctx.info(), ctx.debug(), ctx.warning(), ctx.error() messages appear in real-time
3. Real-time Updates: Context messages update the UI immediately without blocking
4. Proper Timeout Handling: Long-running operations with Context are handled gracefully

In Roo Code (Broken)

1. Timeout Errors: Tools using Context methods fail with "Request timed out" errors
2. No Progress Display: ctx.report_progress() calls are ignored or cause failures
3. No Real-time Logging: Context logging methods don't update the UI
4. Blocking Behavior: Long-running operations with Context cause the entire request to timeout

Technical Details

FastMCP Context Capabilities Not Supported in Roo Code

1. Progress Reporting

   await ctx.report_progress(progress=50, total=100)

2. Logging Methods

   await ctx.debug("Debug message")
   await ctx.info("Info message")
   await ctx.warning("Warning message")
   await ctx.error("Error message")

3. Resource Access

   content = await ctx.read_resource("resource://config")

4. LLM Sampling

   response = await ctx.sample("Analyze this data", temperature=0.7)

5. User Elicitation

   result = await ctx.elicit("Enter your name:", response_type=str)

6. State Management

   ctx.set_state("key", "value")
   value = ctx.get_state("key")

Impact on Development

Current Limitations in Roo Code

1. No Real-time Feedback: Developers cannot provide progress updates during long-running operations
2. Poor User Experience: Users don't see what's happening during tool execution
3. Limited Debugging: No access to Context logging for debugging MCP tools
4. Reduced Functionality: Many advanced FastMCP features are unusable

Benefits of Adding Context Support

1. Better UX: Real-time progress bars and status updates
2. Enhanced Debugging: Comprehensive logging capabilities
3. Advanced Features: Access to LLM sampling, resource management, and user elicitation
4. Professional Tools: Ability to build sophisticated MCP servers with rich interactions

Implementation Requirements

Roo Code MCP Client Updates Needed

1. Context Message Handling: Implement proper handling of Context messages from MCP servers
2. Progress UI Components: Add UI components to display progress bars and status updates
3. Real-time Message Display: Implement real-time display of Context logging messages
4. Timeout Management: Proper handling of long-running operations with Context
5. State Management: Support for Context state management across tool calls

UI/UX Considerations

1. Progress Bar Component: Visual progress indicator for report_progress calls
2. Log Message Display: Dedicated area for displaying Context log messages
3. Real-time Updates: Non-blocking UI updates during tool execution
4. Error Handling: Graceful handling of Context-related errors

Sample Implementation Approach

1. Context Message Handler

interface ContextMessage {
  type: "progress" | "log" | "resource" | "sample" | "elicit";
  data: any;
}

class MCPContextHandler {
  async handleContextMessage(message: ContextMessage) {
    switch (message.type) {
      case "progress":
        this.updateProgress(message.data);
        break;
      case "log":
        this.displayLog(message.data);
        break;
      // ... other handlers
    }
  }
}

2. Progress UI Component

interface ProgressData {
  progress: number;
  total: number;
  description?: string;
}

class ProgressBar {
  update(progress: ProgressData) {
    // Update progress bar UI
    this.progressElement.style.width = `${
      (progress.progress / progress.total) * 100
    }%`;
    this.descriptionElement.textContent = progress.description || "";
  }
}

Priority and Timeline

High Priority

• Basic Context message handling
• Progress reporting support
• Logging message display

Medium Priority

• Resource access support
• State management
• Error handling improvements

Low Priority

• LLM sampling integration
• User elicitation support
• Advanced Context features

Conclusion

FastMCP Context support is essential for building professional-grade MCP servers and providing a good user experience. Roo Code's current lack of Context support significantly limits the capabilities of MCP tools and creates a poor user experience compared to Cursor.

Adding Context support would:

1. Enable real-time progress reporting
2. Provide comprehensive logging capabilities
3. Allow for more sophisticated MCP server implementations
4. Improve the overall developer and user experience
5. Bring Roo Code's MCP capabilities in line with industry standards

This feature request should be prioritized to ensure Roo Code remains competitive in the AI development environment space.

References

• FastMCP Context Documentation
• MCP Specification
• Cursor MCP Implementation

roo code screenshot：

Cursor screenshot：

[markb-trustifi]

FYI. MCP Inspector added Elicitation support in v0.16.2 release:
https://github.com/modelcontextprotocol/inspector/releases/tag/0.16.2