fix merge conflicts

Author: resurgence72

README.md

@@ -8,13 +8,18 @@
 
 <strong>A Go implementation of the Model Context Protocol (MCP), enabling seamless integration between LLM applications and external data sources and tools.</strong>
 
+<br>
+
+[![Tutorial](http://img.youtube.com/vi/qoaeYMrXJH0/0.jpg)](http://www.youtube.com/watch?v=qoaeYMrXJH0 "Tutorial")
+
 </div>
 
 ```go
 package main
 
 import (
     "context"
+    "errors"
     "fmt"
 
     "github.com/mark3labs/mcp-go/mcp"
@@ -49,7 +54,7 @@ func main() {
 func helloHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
     name, ok := request.Params.Arguments["name"].(string)
     if !ok {
-        return mcp.NewToolResultError("name must be a string"), nil
+        return nil, errors.New("name must be a string")
     }
 
     return mcp.NewToolResultText(fmt.Sprintf("Hello, %s!", name)), nil
@@ -103,6 +108,7 @@ package main
 
 import (
     "context"
+    "errors"
     "fmt"
 
     "github.com/mark3labs/mcp-go/mcp"
@@ -152,7 +158,7 @@ func main() {
             result = x * y
         case "divide":
             if y == 0 {
-                return mcp.NewToolResultError("Cannot divide by zero"), nil
+                return nil, errors.New("Cannot divide by zero")
             }
             result = x / y
         }
@@ -314,7 +320,7 @@ s.AddTool(calculatorTool, func(ctx context.Context, request mcp.CallToolRequest)
         result = x * y
     case "divide":
         if y == 0 {
-            return mcp.NewToolResultError("Division by zero is not allowed"), nil
+            return nil, errors.New("Division by zero is not allowed")
         }
         result = x / y
     }
@@ -359,20 +365,20 @@ s.AddTool(httpTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp
         req, err = http.NewRequest(method, url, nil)
     }
     if err != nil {
-        return mcp.NewToolResultError(fmt.Sprintf("Failed to create request: %v", err)), nil
+        return nil, fmt.Errorf("Failed to create request: %v", err)
     }
 
     client := &http.Client{}
     resp, err := client.Do(req)
     if err != nil {
-        return mcp.NewToolResultError(fmt.Sprintf("Request failed: %v", err)), nil
+        return nil, fmt.Errorf("Request failed: %v", err)
     }
     defer resp.Body.Close()
 
     // Return response
     respBody, err := io.ReadAll(resp.Body)
     if err != nil {
-        return mcp.NewToolResultError(fmt.Sprintf("Failed to read response: %v", err)), nil
+        return nil, fmt.Errorf("Failed to read response: %v", err)
     }
 
     return mcp.NewToolResultText(fmt.Sprintf("Status: %d\nBody: %s", resp.StatusCode, string(respBody))), nil
@@ -503,6 +509,18 @@ Prompts can include:
 
 For examples, see the `examples/` directory.
 
+## Extras
+
+### Request Hooks
+
+Hook into the request lifecycle by creating a `Hooks` object with your
+selection among the possible callbacks.  This enables telemetry across all
+functionality, and observability of various facts, for example the ability
+to count improperly-formatted requests, or to log the agent identity during
+initialization.
+
+Add the `Hooks` to the server at the time of creation using the
+`server.WithHooks` option.
 
 ## Contributing
 

client/sse.go

@@ -18,20 +18,6 @@ import (
 	"github.com/mark3labs/mcp-go/mcp"
 )
 
-type Option func(*SSEMCPClient)
-
-func WithHeaders(headers map[string]string) Option {
-	return func(sc *SSEMCPClient) {
-		sc.headers = headers
-	}
-}
-
-func WithSSEReadTimeout(timeout time.Duration) Option {
-	return func(sc *SSEMCPClient) {
-		sc.sseReadTimeout = timeout
-	}
-}
-
 // SSEMCPClient implements the MCPClient interface using Server-Sent Events (SSE).
 // It maintains a persistent HTTP connection to receive server-pushed events
 // while sending requests over regular HTTP POST calls. The client handles
@@ -40,7 +26,6 @@ type SSEMCPClient struct {
 	baseURL        *url.URL
 	endpoint       *url.URL
 	httpClient     *http.Client
-	headers        map[string]string
 	requestID      atomic.Int64
 	responses      map[int64]chan RPCResponse
 	mu             sync.RWMutex
@@ -50,18 +35,33 @@ type SSEMCPClient struct {
 	notifyMu       sync.RWMutex
 	endpointChan   chan struct{}
 	capabilities   mcp.ServerCapabilities
+	headers        map[string]string
 	sseReadTimeout time.Duration
 }
 
+type ClientOption func(*SSEMCPClient)
+
+func WithHeaders(headers map[string]string) ClientOption {
+	return func(sc *SSEMCPClient) {
+		sc.headers = headers
+	}
+}
+
+func WithSSEReadTimeout(timeout time.Duration) ClientOption {
+	return func(sc *SSEMCPClient) {
+		sc.sseReadTimeout = timeout
+	}
+}
+
 // NewSSEMCPClient creates a new SSE-based MCP client with the given base URL.
 // Returns an error if the URL is invalid.
-func NewSSEMCPClient(baseURL string, options ...Option) (*SSEMCPClient, error) {
+func NewSSEMCPClient(baseURL string, options ...ClientOption) (*SSEMCPClient, error) {
 	parsedURL, err := url.Parse(baseURL)
 	if err != nil {
 		return nil, fmt.Errorf("invalid URL: %w", err)
 	}
 
-	sc := &SSEMCPClient{
+	smc := &SSEMCPClient{
 		baseURL:        parsedURL,
 		httpClient:     &http.Client{},
 		responses:      make(map[int64]chan RPCResponse),
@@ -72,10 +72,10 @@ func NewSSEMCPClient(baseURL string, options ...Option) (*SSEMCPClient, error) {
 	}
 
 	for _, opt := range options {
-		opt(sc)
+		opt(smc)
 	}
 
-	return sc, nil
+	return smc, nil
 }
 
 // Start initiates the SSE connection to the server and waits for the endpoint information.
@@ -125,31 +125,37 @@ func (c *SSEMCPClient) Start(ctx context.Context) error {
 func (c *SSEMCPClient) readSSE(reader io.ReadCloser) {
 	defer reader.Close()
 
-	ctx, cancel := context.WithTimeout(context.Background(), c.sseReadTimeout)
-	defer cancel()
-
-	scanner := bufio.NewScanner(reader)
+	br := bufio.NewReader(reader)
 	var event, data string
 
-	var done bool
-	for {
-		if done {
-			break
-		}
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
 
+	for {
 		select {
 		case <-ctx.Done():
-			if err := ctx.Err(); err != nil {
-				fmt.Printf("SSE read timed out: %v\n", err)
-				return
-			}
+			return
 		default:
-			if !scanner.Scan() {
-				done = true
-				break
+			line, err := br.ReadString('\n')
+			if err != nil {
+				if err == io.EOF {
+					// Process any pending event before exit
+					if event != "" && data != "" {
+						c.handleSSEEvent(event, data)
+					}
+					break
+				}
+				select {
+				case <-c.done:
+					return
+				default:
+					fmt.Printf("SSE stream error: %v\n", err)
+					return
+				}
 			}
-			line := scanner.Text()
 
+			// Remove only newline markers
+			line = strings.TrimRight(line, "\r\n")
 			if line == "" {
 				// Empty line means end of event
 				if event != "" && data != "" {
@@ -167,15 +173,6 @@ func (c *SSEMCPClient) readSSE(reader io.ReadCloser) {
 			}
 		}
 	}
-
-	if err := scanner.Err(); err != nil {
-		select {
-		case <-c.done:
-			return
-		default:
-			fmt.Printf("SSE stream error: %v\n", err)
-		}
-	}
 }
 
 // handleSSEEvent processes SSE events based on their type.

examples/custom_context/main.go

@@ -56,7 +56,9 @@ func makeRequest(ctx context.Context, message, token string) (*response, error)
 		return nil, err
 	}
 	req.Header.Set("Authorization", token)
-	req.URL.Query().Add("message", message)
+	query := req.URL.Query()
+	query.Add("message", message)
+	req.URL.RawQuery = query.Encode()
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return nil, err
@@ -67,7 +69,7 @@ func makeRequest(ctx context.Context, message, token string) (*response, error)
 		return nil, err
 	}
 	var r *response
-	if err := json.Unmarshal(body, r); err != nil {
+	if err := json.Unmarshal(body, &r); err != nil {
 		return nil, err
 	}
 	return r, nil

examples/everything/main.go

@@ -29,12 +29,38 @@ const (
 )
 
 func NewMCPServer() *server.MCPServer {
+
+	hooks := &server.Hooks{}
+
+	hooks.AddBeforeAny(func(id any, method mcp.MCPMethod, message any) {
+		fmt.Printf("beforeAny: %s, %v, %v\n", method, id, message)
+	})
+	hooks.AddOnSuccess(func(id any, method mcp.MCPMethod, message any, result any) {
+		fmt.Printf("onSuccess: %s, %v, %v, %v\n", method, id, message, result)
+	})
+	hooks.AddOnError(func(id any, method mcp.MCPMethod, message any, err error) {
+		fmt.Printf("onError: %s, %v, %v, %v\n", method, id, message, err)
+	})
+	hooks.AddBeforeInitialize(func(id any, message *mcp.InitializeRequest) {
+		fmt.Printf("beforeInitialize: %v, %v\n", id, message)
+	})
+	hooks.AddAfterInitialize(func(id any, message *mcp.InitializeRequest, result *mcp.InitializeResult) {
+		fmt.Printf("afterInitialize: %v, %v, %v\n", id, message, result)
+	})
+	hooks.AddAfterCallTool(func(id any, message *mcp.CallToolRequest, result *mcp.CallToolResult) {
+		fmt.Printf("afterCallTool: %v, %v, %v\n", id, message, result)
+	})
+	hooks.AddBeforeCallTool(func(id any, message *mcp.CallToolRequest) {
+		fmt.Printf("beforeCallTool: %v, %v\n", id, message)
+	})
+
 	mcpServer := server.NewMCPServer(
 		"example-servers/everything",
 		"1.0.0",
 		server.WithResourceCapabilities(true, true),
 		server.WithPromptCapabilities(true),
 		server.WithLogging(),
+		server.WithHooks(hooks),
 	)
 
 	mcpServer.AddResource(mcp.NewResource("test://static/resource",
@@ -300,6 +326,7 @@ func handleSendNotification(
 	server := server.ServerFromContext(ctx)
 
 	err := server.SendNotificationToClient(
+		ctx,
 		"notifications/progress",
 		map[string]interface{}{
 			"progress":      10,
@@ -336,6 +363,7 @@ func handleLongRunningOperationTool(
 		time.Sleep(time.Duration(stepDuration * float64(time.Second)))
 		if progressToken != nil {
 			server.SendNotificationToClient(
+				ctx,
 				"notifications/progress",
 				map[string]interface{}{
 					"progress":      i,

go.mod

@@ -5,6 +5,7 @@ go 1.23
 require (
 	github.com/google/uuid v1.6.0
 	github.com/stretchr/testify v1.9.0
+	github.com/yosida95/uritemplate/v3 v3.0.2
 )
 
 require (

go.sum

@@ -6,6 +6,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zIM+UJPGz4=
+github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

mcp/resources.go

@@ -1,5 +1,7 @@
 package mcp
 
+import "github.com/yosida95/uritemplate/v3"
+
 // ResourceOption is a function that configures a Resource.
 // It provides a flexible way to set various properties of a Resource using the functional options pattern.
 type ResourceOption func(*Resource)
@@ -60,7 +62,7 @@ type ResourceTemplateOption func(*ResourceTemplate)
 // Options are applied in order, allowing for flexible template configuration.
 func NewResourceTemplate(uriTemplate string, name string, opts ...ResourceTemplateOption) ResourceTemplate {
 	template := ResourceTemplate{
-		URITemplate: uriTemplate,
+		URITemplate: &URITemplate{Template: uritemplate.MustNew(uriTemplate)},
 		Name:        name,
 	}