[#67] Fix Client's ReadResource method

client.go

@@ -235,17 +235,13 @@ func (c *Client) ReadResource(ctx context.Context, uri string) (*ResourceRespons
 		return nil, errors.New("invalid response type")
 	}
 
-	var resourceResponse resourceResponseSent
+	var resourceResponse ResourceResponse
 	err = json.Unmarshal(responseBytes, &resourceResponse)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to unmarshal resource response")
 	}
 
-	if resourceResponse.Error != nil {
-		return nil, resourceResponse.Error
-	}
-
-	return resourceResponse.Response, nil
+	return &resourceResponse, nil
 }
 
 // Ping sends a ping request to the server to check connectivity

content_api.go

@@ -85,14 +85,51 @@ type EmbeddedResource struct {
 
 // Custom JSON marshaling for EmbeddedResource
 func (c EmbeddedResource) MarshalJSON() ([]byte, error) {
+	type wrapper struct {
+		Type string `json:"embeddedResourceType"`
+		*TextResourceContents
+		*BlobResourceContents
+	}
+
+	w := wrapper{Type: string(c.EmbeddedResourceType)}
+
 	switch c.EmbeddedResourceType {
 	case embeddedResourceTypeBlob:
-		return json.Marshal(c.BlobResourceContents)
+		w.BlobResourceContents = c.BlobResourceContents
 	case embeddedResourceTypeText:
-		return json.Marshal(c.TextResourceContents)
+		w.TextResourceContents = c.TextResourceContents
 	default:
 		return nil, fmt.Errorf("unknown embedded resource type: %s", c.EmbeddedResourceType)
 	}
+
+	return json.Marshal(w)
+}
+
+func (c *EmbeddedResource) UnmarshalJSON(data []byte) error {
+	var wrapper struct {
+		Type string          `json:"embeddedResourceType"`
+		Raw  json.RawMessage `json:"-"`
+	}
+
+	wrapper.Raw = data
+	if err := json.Unmarshal(data, &wrapper); err != nil {
+		return err
+	}
+
+	c.EmbeddedResourceType = embeddedResourceType(wrapper.Type)
+
+	switch c.EmbeddedResourceType {
+	case embeddedResourceTypeText:
+		c.TextResourceContents = new(TextResourceContents)
+		return json.Unmarshal(wrapper.Raw, c.TextResourceContents)
+
+	case embeddedResourceTypeBlob:
+		c.BlobResourceContents = new(BlobResourceContents)
+		return json.Unmarshal(wrapper.Raw, c.BlobResourceContents)
+
+	default:
+		return fmt.Errorf("unknown resource type: %s", wrapper.Type)
+	}
 }
 
 type ContentType string

transport/http/http.go

@@ -5,22 +5,14 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"sync"
-
-	"github.com/metoro-io/mcp-golang/transport"
 )
 
 // HTTPTransport implements a stateless HTTP transport for MCP
 type HTTPTransport struct {
 	*baseTransport
-	server         *http.Server
-	endpoint       string
-	messageHandler func(ctx context.Context, message *transport.BaseJsonRpcMessage)
-	errorHandler   func(error)
-	closeHandler   func()
-	mu             sync.RWMutex
-	addr           string
-	responseMap    map[int64]chan *transport.BaseJsonRpcMessage
+	server   *http.Server
+	endpoint string
+	addr     string
 }
 
 // NewHTTPTransport creates a new HTTP transport that listens on the specified endpoint
@@ -29,7 +21,6 @@ func NewHTTPTransport(endpoint string) *HTTPTransport {
 		baseTransport: newBaseTransport(),
 		endpoint:      endpoint,
 		addr:          ":8080", // Default port
-		responseMap:   make(map[int64]chan *transport.BaseJsonRpcMessage),
 	}
 }
 
@@ -52,49 +43,15 @@ func (t *HTTPTransport) Start(ctx context.Context) error {
 	return t.server.ListenAndServe()
 }
 
-// Send implements Transport.Send
-func (t *HTTPTransport) Send(ctx context.Context, message *transport.BaseJsonRpcMessage) error {
-	key := message.JsonRpcResponse.Id
-	responseChannel := t.responseMap[int64(key)]
-	if responseChannel == nil {
-		return fmt.Errorf("no response channel found for key: %d", key)
-	}
-	responseChannel <- message
-	return nil
-}
-
 // Close implements Transport.Close
 func (t *HTTPTransport) Close() error {
 	if t.server != nil {
 		if err := t.server.Close(); err != nil {
 			return err
 		}
 	}
-	if t.closeHandler != nil {
-		t.closeHandler()
-	}
-	return nil
-}
-
-// SetCloseHandler implements Transport.SetCloseHandler
-func (t *HTTPTransport) SetCloseHandler(handler func()) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	t.closeHandler = handler
-}
-
-// SetErrorHandler implements Transport.SetErrorHandler
-func (t *HTTPTransport) SetErrorHandler(handler func(error)) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	t.errorHandler = handler
-}
 
-// SetMessageHandler implements Transport.SetMessageHandler
-func (t *HTTPTransport) SetMessageHandler(handler func(ctx context.Context, message *transport.BaseJsonRpcMessage)) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	t.messageHandler = handler
+	return t.baseTransport.Close()
 }
 
 func (t *HTTPTransport) handleRequest(w http.ResponseWriter, r *http.Request) {