change to strong ResourceContents type

Author: Zheng Li

client/sse.go

@@ -412,12 +412,7 @@ func (c *SSEMCPClient) ReadResource(
 		return nil, err
 	}
 
-	var result mcp.ReadResourceResult
-	if err := json.Unmarshal(*response, &result); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
-	}
-
-	return &result, nil
+	return mcp.ParseReadResourceResult(response)
 }
 
 func (c *SSEMCPClient) Subscribe(

client/stdio.go

@@ -338,12 +338,7 @@ func (c *StdioMCPClient) ReadResource(
 		return nil, err
 	}
 
-	var result mcp.ReadResourceResult
-	if err := json.Unmarshal(*response, &result); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
-	}
-
-	return &result, nil
+	return mcp.ParseReadResourceResult(response)
 }
 
 func (c *StdioMCPClient) Subscribe(

examples/everything/main.go

@@ -173,29 +173,25 @@ func runUpdateInterval() {
 func handleReadResource(
 	ctx context.Context,
 	request mcp.ReadResourceRequest,
-) ([]interface{}, error) {
-	return []interface{}{
+) ([]mcp.ResourceContents, error) {
+	return []mcp.ResourceContents{
 		mcp.TextResourceContents{
-			ResourceContents: mcp.ResourceContents{
-				URI:      "test://static/resource",
-				MIMEType: "text/plain",
-			},
-			Text: "This is a sample resource",
+			URI:      "test://static/resource",
+			MIMEType: "text/plain",
+			Text:     "This is a sample resource",
 		},
 	}, nil
 }
 
 func handleResourceTemplate(
 	ctx context.Context,
 	request mcp.ReadResourceRequest,
-) ([]interface{}, error) {
-	return []interface{}{
+) ([]mcp.ResourceContents, error) {
+	return []mcp.ResourceContents{
 		mcp.TextResourceContents{
-			ResourceContents: mcp.ResourceContents{
-				URI:      request.Params.URI,
-				MIMEType: "text/plain",
-			},
-			Text: "This is a sample resource",
+			URI:      request.Params.URI,
+			MIMEType: "text/plain",
+			Text:     "This is a sample resource",
 		},
 	}, nil
 }

mcp/types.go

@@ -373,7 +373,7 @@ type ReadResourceRequest struct {
 // from the client.
 type ReadResourceResult struct {
 	Result
-	Contents []interface{} `json:"contents"` // Can be TextResourceContents or BlobResourceContents
+	Contents []ResourceContents `json:"contents"` // Can be TextResourceContents or BlobResourceContents
 }
 
 // ResourceListChangedNotification is an optional notification from the server
@@ -459,26 +459,33 @@ type ResourceTemplate struct {
 
 // ResourceContents represents the contents of a specific resource or sub-
 // resource.
-type ResourceContents struct {
+type ResourceContents interface {
+	isResourceContents()
+}
+
+type TextResourceContents struct {
 	// The URI of this resource.
 	URI string `json:"uri"`
 	// The MIME type of this resource, if known.
 	MIMEType string `json:"mimeType,omitempty"`
-}
-
-type TextResourceContents struct {
-	ResourceContents
 	// The text of the item. This must only be set if the item can actually be
 	// represented as text (not binary data).
 	Text string `json:"text"`
 }
 
+func (TextResourceContents) isResourceContents() {}
+
 type BlobResourceContents struct {
-	ResourceContents
+	// The URI of this resource.
+	URI string `json:"uri"`
+	// The MIME type of this resource, if known.
+	MIMEType string `json:"mimeType,omitempty"`
 	// A base64-encoded string representing the binary data of the item.
 	Blob string `json:"blob"`
 }
 
+func (BlobResourceContents) isResourceContents() {}
+
 /* Logging */
 
 // SetLevelRequest is a request from the client to the server, to enable or

mcp/utils.go

@@ -305,7 +305,7 @@ func NewListResourceTemplatesResult(
 // NewReadResourceResult creates a new ReadResourceResult with text content
 func NewReadResourceResult(text string) *ReadResourceResult {
 	return &ReadResourceResult{
-		Contents: []interface{}{
+		Contents: []ResourceContents{
 			TextResourceContents{
 				Text: text,
 			},
@@ -410,22 +410,12 @@ func ParseContent(contentMap map[string]any) (Content, error) {
 			return nil, fmt.Errorf("resource is missing")
 		}
 
-		uri := ExtractString(resourceMap, "uri")
-		mimeType := ExtractString(resourceMap, "mimeType")
-		text := ExtractString(resourceMap, "text")
-
-		if uri == "" || mimeType == "" {
-			return nil, fmt.Errorf("resource uri or mimeType is missing")
+		resourceContents, err := ParseResourceContents(resourceMap)
+		if err != nil {
+			return nil, err
 		}
 
-		if text != "" {
-			return NewEmbeddedResource(
-				ResourceContents{
-					URI:      uri,
-					MIMEType: mimeType,
-				},
-			), nil
-		}
+		return NewEmbeddedResource(resourceContents), nil
 	}
 
 	return nil, fmt.Errorf("unsupported content type: %s", contentType)
@@ -543,3 +533,74 @@ func ParseCallToolResult(rawMessage *json.RawMessage) (*CallToolResult, error) {
 
 	return &result, nil
 }
+
+func ParseResourceContents(contentMap map[string]any) (ResourceContents, error) {
+	uri := ExtractString(contentMap, "uri")
+	if uri == "" {
+		return nil, fmt.Errorf("resource uri is missing")
+	}
+
+	mimeType := ExtractString(contentMap, "mimeType")
+
+	if text := ExtractString(contentMap, "text"); text != "" {
+		return TextResourceContents{
+			URI:      uri,
+			MIMEType: mimeType,
+			Text:     text,
+		}, nil
+	}
+
+	if blob := ExtractString(contentMap, "blob"); blob != "" {
+		return BlobResourceContents{
+			URI:      uri,
+			MIMEType: mimeType,
+			Blob:     blob,
+		}, nil
+	}
+
+	return nil, fmt.Errorf("unsupported resource type")
+}
+
+func ParseReadResourceResult(rawMessage *json.RawMessage) (*ReadResourceResult, error) {
+	var jsonContent map[string]any
+	if err := json.Unmarshal(*rawMessage, &jsonContent); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+
+	var result ReadResourceResult
+
+	meta, ok := jsonContent["_meta"]
+	if ok {
+		if metaMap, ok := meta.(map[string]any); ok {
+			result.Meta = metaMap
+		}
+	}
+
+	contents, ok := jsonContent["contents"]
+	if !ok {
+		return nil, fmt.Errorf("contents is missing")
+	}
+
+	contentArr, ok := contents.([]any)
+	if !ok {
+		return nil, fmt.Errorf("contents is not an array")
+	}
+
+	for _, content := range contentArr {
+		// Extract content
+		contentMap, ok := content.(map[string]any)
+		if !ok {
+			return nil, fmt.Errorf("content is not an object")
+		}
+
+		// Process content
+		content, err := ParseResourceContents(contentMap)
+		if err != nil {
+			return nil, err
+		}
+
+		result.Contents = append(result.Contents, content)
+	}
+
+	return &result, nil
+}

server/server.go

@@ -29,10 +29,10 @@ type resourceTemplateEntry struct {
 type ServerOption func(*MCPServer)
 
 // ResourceHandlerFunc is a function that returns resource contents.
-type ResourceHandlerFunc func(ctx context.Context, request mcp.ReadResourceRequest) ([]interface{}, error)
+type ResourceHandlerFunc func(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error)
 
 // ResourceTemplateHandlerFunc is a function that returns a resource template.
-type ResourceTemplateHandlerFunc func(ctx context.Context, request mcp.ReadResourceRequest) ([]interface{}, error)
+type ResourceTemplateHandlerFunc func(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error)
 
 // PromptHandlerFunc handles prompt requests with given arguments.
 type PromptHandlerFunc func(ctx context.Context, request mcp.GetPromptRequest) (*mcp.GetPromptResult, error)

server/server_test.go

@@ -674,14 +674,12 @@ func createTestServer() *MCPServer {
 			URI:  "resource://testresource",
 			Name: "My Resource",
 		},
-		func(ctx context.Context, request mcp.ReadResourceRequest) ([]interface{}, error) {
-			return []interface{}{
+		func(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) {
+			return []mcp.ResourceContents{
 				mcp.TextResourceContents{
-					ResourceContents: mcp.ResourceContents{
-						URI:      "resource://testresource",
-						MIMEType: "text/plain",
-					},
-					Text: "test content",
+					URI:      "resource://testresource",
+					MIMEType: "text/plain",
+					Text:     "test content",
 				},
 			}, nil
 		},