refactor!: replace mcp-go with the official MCP Go SDK

- Swap the mark3labs MCP dependency for modelcontextprotocol/go-sdk v1.7.0
- Add a declarative tool definition and JSON Schema builder to the tool package
- Adapt registered tools to the official low-level handler, recovering panics and mapping failures to JSON-RPC errors
- Narrow tool handlers to take a plain argument map instead of an SDK request type
- Rewire stdio and HTTP transports onto the official server, moving Authorization parsing into receiving middleware
- Add a golden contract test that locks the exposed tool schemas, plus SDK integration and helper tests
- Add a test target and run it in the pull request workflow

BREAKING CHANGE: The exported helpers change signature. Tool.RegisterRead and
Tool.RegisterWrite now take tool.ServerTool instead of server.ServerTool, and the
annotation constructors return *mcp.ToolAnnotations from the official SDK. Callers
must build tool definitions with tool.NewDefinition and handlers with the
func(context.Context, map[string]any) signature.

The 30-second SSE heartbeat is removed because the official SDK has no equivalent.
ServerOptions.KeepAlive is deliberately not used as a substitute, since it sends MCP
ping requests and ping is removed in protocol 2026. HTTP stays stateless=false, so
new clients negotiate at most 2025-11-25.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

pkg/tool/tool.go

@@ -1,26 +1,39 @@
 package tool
 
 import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
 	"slices"
 	"strings"
 
 	"gitea.com/gitea/gitea-mcp/pkg/flag"
 	"gitea.com/gitea/gitea-mcp/pkg/log"
 
-	"github.com/mark3labs/mcp-go/server"
+	"github.com/modelcontextprotocol/go-sdk/jsonrpc"
+	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
 
+type Handler func(context.Context, map[string]any) (*mcp.CallToolResult, error)
+
+type ServerTool struct {
+	Tool    *mcp.Tool
+	Handler Handler
+}
+
 type Tool struct {
 	scope string
-	write []server.ServerTool
-	read  []server.ServerTool
+	write []ServerTool
+	read  []ServerTool
 }
 
 func New(scope string) *Tool {
 	return &Tool{
 		scope: scope,
-		write: make([]server.ServerTool, 0, 100),
-		read:  make([]server.ServerTool, 0, 100),
+		write: make([]ServerTool, 0, 100),
+		read:  make([]ServerTool, 0, 100),
 	}
 }
 
@@ -29,23 +42,23 @@ func (t *Tool) Scope() string {
 	return t.scope
 }
 
-func (t *Tool) RegisterWrite(s server.ServerTool) {
+func (t *Tool) RegisterWrite(s ServerTool) {
 	t.write = append(t.write, s)
 }
 
-func (t *Tool) RegisterRead(s server.ServerTool) {
+func (t *Tool) RegisterRead(s ServerTool) {
 	t.read = append(t.read, s)
 }
 
 // ReadTools returns the read-only tools registered on this domain, ignoring
 // the read-only and allowlist flags that Tools applies.
-func (t *Tool) ReadTools() []server.ServerTool {
+func (t *Tool) ReadTools() []ServerTool {
 	return t.read
 }
 
 // WriteTools returns the write tools registered on this domain, ignoring the
 // read-only and allowlist flags that Tools applies.
-func (t *Tool) WriteTools() []server.ServerTool {
+func (t *Tool) WriteTools() []ServerTool {
 	return t.write
 }
 
@@ -53,8 +66,8 @@ func (t *Tool) WriteTools() []server.ServerTool {
 // read-only filter and the scope/tool allowlists (union semantics: a tool is
 // kept if its domain's scope is in AllowedScopes OR its name is in
 // AllowedTools). With no allowlists set, all tools pass through unchanged.
-func (t *Tool) Tools() []server.ServerTool {
-	all := make([]server.ServerTool, 0, len(t.write)+len(t.read))
+func (t *Tool) Tools() []ServerTool {
+	all := make([]ServerTool, 0, len(t.write)+len(t.read))
 	if !flag.ReadOnly {
 		all = append(all, t.write...)
 	}
@@ -63,7 +76,7 @@ func (t *Tool) Tools() []server.ServerTool {
 		return all
 	}
 	_, scopeAllowed := flag.AllowedScopes[t.scope]
-	filtered := make([]server.ServerTool, 0, len(all))
+	filtered := make([]ServerTool, 0, len(all))
 	for _, st := range all {
 		_, toolAllowed := flag.AllowedTools[st.Tool.Name]
 		if scopeAllowed || toolAllowed {
@@ -73,6 +86,70 @@ func (t *Tool) Tools() []server.ServerTool {
 	return filtered
 }
 
+// MCPHandler adapts a project handler to the official SDK's low-level handler.
+func (s ServerTool) MCPHandler() mcp.ToolHandler {
+	return func(ctx context.Context, req *mcp.CallToolRequest) (result *mcp.CallToolResult, err error) {
+		name := ""
+		if s.Tool != nil {
+			name = s.Tool.Name
+		}
+		defer func() {
+			if recovered := recover(); recovered != nil {
+				panicErr := fmt.Errorf("panic recovered in %s tool handler: %v", name, recovered)
+				log.Errorf("%s", panicErr)
+				result = nil
+				err = &jsonrpc.Error{Code: jsonrpc.CodeInternalError, Message: panicErr.Error()}
+			}
+		}()
+
+		if req == nil || req.Params == nil {
+			return nil, invalidParamsError("missing tool call parameters")
+		}
+
+		arguments, err := decodeArguments(req.Params.Arguments)
+		if err != nil {
+			return nil, err
+		}
+		if s.Handler == nil {
+			return nil, internalError(fmt.Errorf("tool %q has no handler", name))
+		}
+
+		result, err = s.Handler(ctx, arguments)
+		if err != nil {
+			var protocolErr *jsonrpc.Error
+			if errors.As(err, &protocolErr) {
+				return nil, err
+			}
+			return nil, internalError(err)
+		}
+		return result, nil
+	}
+}
+
+func decodeArguments(raw json.RawMessage) (map[string]any, error) {
+	trimmed := bytes.TrimSpace(raw)
+	if len(trimmed) == 0 {
+		return map[string]any{}, nil
+	}
+	if bytes.Equal(trimmed, []byte("null")) {
+		return nil, invalidParamsError("tool arguments must be an object")
+	}
+
+	var arguments map[string]any
+	if err := json.Unmarshal(trimmed, &arguments); err != nil {
+		return nil, invalidParamsError(fmt.Sprintf("invalid tool arguments: %v", err))
+	}
+	return arguments, nil
+}
+
+func invalidParamsError(message string) error {
+	return &jsonrpc.Error{Code: jsonrpc.CodeInvalidParams, Message: message}
+}
+
+func internalError(err error) error {
+	return &jsonrpc.Error{Code: jsonrpc.CodeInternalError, Message: err.Error()}
+}
+
 // warnUnmatched logs the names present in allowlist but absent from known,
 // via logUnmatched, so WarnUnmatchedAllowedTools and WarnUnmatchedAllowedScopes
 // share the same "collect, sort, no-op when empty" logic and can't drift.