Feature/native mcp server 2 (#26)

Author: mqasimca

internal/adapters/mcp/executor_branches2_test.go

@@ -2,6 +2,7 @@ package mcp
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"testing"
 	"time"
@@ -385,17 +386,14 @@ func TestHandleToolCall_NilArguments(t *testing.T) {
 	ctx := context.Background()
 	s := newMockServer(&mockNylasClient{})
 
+	params, _ := json.Marshal(ToolCallParams{
+		Name:      "current_time",
+		Arguments: nil,
+	})
 	req := &Request{
 		JSONRPC: "2.0",
 		Method:  "tools/call",
-		Params: struct {
-			Name      string         `json:"name"`
-			Arguments map[string]any `json:"arguments"`
-			Cursor    string         `json:"cursor,omitempty"`
-		}{
-			Name:      "current_time",
-			Arguments: nil,
-		},
+		Params:  params,
 	}
 
 	raw := s.handleToolCall(ctx, req)
@@ -417,4 +415,3 @@ func TestHandleToolCall_NilArguments(t *testing.T) {
 		t.Errorf("unexpected tool error with nil arguments: %s", text)
 	}
 }
-

internal/adapters/mcp/executor_messages.go

@@ -2,11 +2,39 @@ package mcp
 
 import (
 	"context"
+	"strings"
 	"time"
 
 	"github.com/nylas/cli/internal/domain"
 )
 
+// maxSnippetLen caps snippet length to reduce token usage in list responses.
+const maxSnippetLen = 120
+
+// cleanSnippet removes invisible padding characters and trims to a reasonable length.
+func cleanSnippet(s string) string {
+	// Remove zero-width non-joiners, zero-width spaces, and other invisible chars.
+	s = strings.NewReplacer(
+		"\u200c", "", // zero-width non-joiner (‌)
+		"\u200b", "", // zero-width space
+		"\u034f", "", // combining grapheme joiner (͏)
+		"\r\n", " ",
+		"\r", " ",
+		"\n", " ",
+	).Replace(s)
+
+	// Collapse multiple spaces.
+	for strings.Contains(s, "  ") {
+		s = strings.ReplaceAll(s, "  ", " ")
+	}
+	s = strings.TrimSpace(s)
+
+	if len(s) > maxSnippetLen {
+		s = s[:maxSnippetLen] + "..."
+	}
+	return s
+}
+
 // parseParticipants extracts email participants from tool arguments.
 // Accepts an array of objects with "email" and optional "name" fields.
 func parseParticipants(args map[string]any, key string) []domain.EmailParticipant {
@@ -84,9 +112,8 @@ func (s *Server) executeListMessages(ctx context.Context, args map[string]any) *
 			"date":      msg.Date.Format(time.RFC3339),
 			"unread":    msg.Unread,
 			"starred":   msg.Starred,
-			"snippet":   msg.Snippet,
+			"snippet":   cleanSnippet(msg.Snippet),
 			"thread_id": msg.ThreadID,
-			"folders":   msg.Folders,
 		})
 	}
 	return toolSuccess(result)

internal/adapters/mcp/handlers.go

@@ -6,15 +6,38 @@ import (
 	"time"
 )
 
-// Protocol version and server info.
+// Supported protocol versions (newest first).
+var supportedVersions = []string{
+	"2025-03-26",
+	"2024-11-05",
+}
+
+// latestVersion is the most recent protocol version this server supports.
+const latestVersion = "2025-03-26"
+
+// Server info constants.
 const (
-	protocolVersion = "2024-11-05"
-	serverName      = "nylas-mcp"
-	serverVersion   = "1.0.0"
+	serverName    = "nylas-mcp"
+	serverVersion = "1.0.0"
 )
 
+// negotiateVersion returns the newest version both client and server support.
+// If the client's requested version is in our supported list, return it.
+// Otherwise, return the latest version we support.
+func negotiateVersion(requested string) string {
+	for _, v := range supportedVersions {
+		if v == requested {
+			return v
+		}
+	}
+	return latestVersion
+}
+
 // handleInitialize responds to the MCP initialize request with server capabilities.
 func (s *Server) handleInitialize(req *Request) []byte {
+	params := parseInitializeParams(req.Params)
+	negotiated := negotiateVersion(params.ProtocolVersion)
+
 	// Detect user's timezone for guidance
 	localZone, _ := time.Now().Zone()
 	tzName := time.Local.String()
@@ -28,11 +51,11 @@ IMPORTANT - Timezone Consistency:
 The user's local timezone is: %s (%s)
 When displaying ANY timestamps to users (from emails, events, availability, etc.):
 1. Always use epoch_to_datetime tool with timezone "%s" to convert Unix timestamps
-2. Display ALL times in %s, never in UTC or the event's original timezone
+2. Display ALL times in %s, never in UTC
 3. Format times clearly (e.g., "2:00 PM %s")`, tzName, localZone, tzName, localZone, localZone)
 
 	result := map[string]any{
-		"protocolVersion": protocolVersion,
+		"protocolVersion": negotiated,
 		"capabilities": map[string]any{
 			"tools": map[string]any{},
 		},
@@ -57,8 +80,9 @@ func (s *Server) handleToolsList(req *Request) []byte {
 
 // handleToolCall dispatches a tool call to the appropriate executor.
 func (s *Server) handleToolCall(ctx context.Context, req *Request) []byte {
-	name := req.Params.Name
-	args := req.Params.Arguments
+	params := parseToolCallParams(req.Params)
+	name := params.Name
+	args := params.Arguments
 	if args == nil {
 		args = make(map[string]any)
 	}
@@ -183,7 +207,7 @@ func (s *Server) handleToolCall(ctx context.Context, req *Request) []byte {
 		result = s.executeDatetimeToEpoch(args)
 
 	default:
-		result = toolError(fmt.Sprintf("unknown tool: %s", name))
+		return errorResponse(req.ID, codeInvalidParams, fmt.Sprintf("unknown tool: %s", name))
 	}
 
 	return successResponse(req.ID, result)

internal/adapters/mcp/handlers_test.go

@@ -157,17 +157,15 @@ func parseToolResult(t *testing.T, resp jsonRPCResponse) toolResult {
 
 // makeReq builds a minimal tools/call Request with the given tool name and args.
 func makeReq(name string, args map[string]any) *Request {
+	params := ToolCallParams{
+		Name:      name,
+		Arguments: args,
+	}
+	raw, _ := json.Marshal(params)
 	return &Request{
 		JSONRPC: "2.0",
 		Method:  "tools/call",
-		Params: struct {
-			Name      string         `json:"name"`
-			Arguments map[string]any `json:"arguments"`
-			Cursor    string         `json:"cursor,omitempty"`
-		}{
-			Name:      name,
-			Arguments: args,
-		},
+		Params:  raw,
 	}
 }
 
@@ -310,24 +308,15 @@ func TestHandleToolCall_UnknownTool(t *testing.T) {
 	req := makeReq("no_such_tool", map[string]any{})
 	raw := s.handleToolCall(ctx, req)
 
-	// The dispatch always wraps in successResponse, so JSON-RPC level has no error.
+	// Unknown tool now returns a JSON-RPC error with code -32602.
 	rpc := parseRPCResponse(t, raw)
-	if rpc.Error != nil {
-		t.Fatalf("expected result (not JSON-RPC error) for unknown tool, got error: %s", rpc.Error.Message)
-	}
-	if rpc.Result == nil {
-		t.Fatal("result field is missing")
-	}
-
-	// The tool result itself should have isError=true with "unknown tool" message.
-	tr := parseToolResult(t, rpc)
-	if !tr.IsError {
-		t.Error("expected isError=true for unknown tool, got isError=false")
+	if rpc.Error == nil {
+		t.Fatal("expected JSON-RPC error for unknown tool, got result")
 	}
-	if len(tr.Content) == 0 {
-		t.Fatal("expected at least one content block in error response")
+	if rpc.Error.Code != codeInvalidParams {
+		t.Errorf("error.code = %d, want %d", rpc.Error.Code, codeInvalidParams)
 	}
-	if !strings.Contains(tr.Content[0].Text, "unknown tool") {
-		t.Errorf("expected error text to contain 'unknown tool', got: %s", tr.Content[0].Text)
+	if !strings.Contains(rpc.Error.Message, "unknown tool") {
+		t.Errorf("expected error message to contain 'unknown tool', got: %s", rpc.Error.Message)
 	}
 }