Merge branch 'main' into bo/include-verbose-logging

Author: BolajiOlajide

cmd/src/mcp.go

@@ -85,7 +85,7 @@ func mcpMain(args []string) error {
 		return err
 	}
 
-	output, err := json.MarshalIndent(result, "", "  ")
+	output, err := json.Marshal(result)
 	if err != nil {
 		return err
 	}
@@ -94,11 +94,11 @@ func mcpMain(args []string) error {
 }
 
 func printSchemas(tool *mcp.ToolDef) error {
-	input, err := json.MarshalIndent(tool.InputSchema, "", " ")
+	input, err := json.Marshal(tool.InputSchema)
 	if err != nil {
 		return err
 	}
-	output, err := json.MarshalIndent(tool.OutputSchema, "", " ")
+	output, err := json.Marshal(tool.OutputSchema)
 	if err != nil {
 		return err
 	}

internal/mcp/mcp_request.go

@@ -14,18 +14,17 @@ import (
 )
 
 const MCPURLPath = ".api/mcp/v1"
-const MCPDeepSearchURLPath = ".api/mcp/deepsearch"
 
 func fetchToolDefinitions(ctx context.Context, client api.Client, endpoint string) (map[string]*ToolDef, error) {
 	resp, err := doJSONRPC(ctx, client, endpoint, "tools/list", nil)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to list tools from mcp endpoint")
+		return nil, errors.Wrapf(err, "JSON-RPC tools/list request failed to %q", MCPURLPath)
 	}
 	defer resp.Body.Close()
 
 	data, err := readSSEResponseData(resp)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to read list tools SSE response")
+		return nil, errors.Wrap(err, "failed to read tools/list SSE response")
 	}
 
 	var rpcResp struct {
@@ -54,7 +53,11 @@ func doToolCall(ctx context.Context, client api.Client, endpoint string, tool st
 		Arguments: vars,
 	}
 
-	return doJSONRPC(ctx, client, endpoint, "tools/call", params)
+	resp, err := doJSONRPC(ctx, client, endpoint, "tools/call", params)
+	if err != nil {
+		return nil, errors.Wrapf(err, "JSON-RPC tools/call request failed to %q", MCPURLPath)
+	}
+	return resp, err
 }
 
 func doJSONRPC(ctx context.Context, client api.Client, endpoint string, method string, params any) (*http.Response, error) {
@@ -123,18 +126,19 @@ func decodeToolResponse(resp *http.Response) (map[string]json.RawMessage, error)
 		return nil, errors.Wrapf(err, "failed to unmarshal MCP JSON-RPC response")
 	}
 	if jsonRPCResp.Error != nil {
-		return nil, errors.Newf("MCP tools/call failed: %d %s", jsonRPCResp.Error.Code, jsonRPCResp.Error.Message)
+		return nil, errors.Newf("MCP JSON-RPC error: %d %s", jsonRPCResp.Error.Code, jsonRPCResp.Error.Message)
 	}
 
 	if jsonRPCResp.Result.IsError {
-		if len(jsonRPCResp.Result.Content) > 0 {
+		content := jsonRPCResp.Result.Content[0]
+		if len(content) > 0 {
 			var textContent struct {
 				Text string `json:"text"`
 			}
-			if err := json.Unmarshal(jsonRPCResp.Result.Content[0], &textContent); err == nil && textContent.Text != "" {
+			if err := json.Unmarshal(content, &textContent); err == nil && textContent.Text != "" {
 				return nil, errors.Newf("MCP tool error: %s", textContent.Text)
 			}
-			return nil, errors.Newf("MCP tool error: %s", string(jsonRPCResp.Result.Content[0]))
+			return nil, errors.Newf("MCP tool error: %s", string(content))
 		}
 		return nil, errors.New("MCP tool returned an error")
 	}

internal/mcp/registry.go

@@ -8,51 +8,29 @@ import (
 	"slices"
 
 	"github.com/sourcegraph/src-cli/internal/api"
-
-	"github.com/sourcegraph/sourcegraph/lib/errors"
 )
 
 // ToolRegistry keeps track of tools and the endpoints they originated from
 type ToolRegistry struct {
-	tools     map[string]*ToolDef
-	endpoints map[string]string
+	tools map[string]*ToolDef
 }
 
 func NewToolRegistry() *ToolRegistry {
 	return &ToolRegistry{
-		tools:     make(map[string]*ToolDef),
-		endpoints: make(map[string]string),
+		tools: make(map[string]*ToolDef),
 	}
 }
 
-// LoadTools loads the tool definitions from the Mcp tool endpoints constants McpURLPath and McpDeepSearchURLPath
+// LoadTools loads the tool definitions from the Mcp tool endpoints constants McpURLPath
 func (r *ToolRegistry) LoadTools(ctx context.Context, client api.Client) error {
-	endpoints := []string{MCPURLPath, MCPDeepSearchURLPath}
-
-	var errs []error
-	for _, endpoint := range endpoints {
-		tools, err := fetchToolDefinitions(ctx, client, endpoint)
-		if err != nil {
-			errs = append(errs, errors.Wrapf(err, "failed to load tools from %s", endpoint))
-			continue
-		}
-		r.register(endpoint, tools)
-	}
-
-	if len(errs) > 0 {
-		return errors.Append(nil, errs...)
+	tools, err := fetchToolDefinitions(ctx, client, MCPURLPath)
+	if err != nil {
+		return err
 	}
+	r.tools = tools
 	return nil
 }
 
-// register associates a collection of tools with the given endpoint
-func (r *ToolRegistry) register(endpoint string, tools map[string]*ToolDef) {
-	for name, def := range tools {
-		r.tools[name] = def
-		r.endpoints[name] = endpoint
-	}
-}
-
 // Get returns the tool definition for the given name
 func (r *ToolRegistry) Get(name string) (*ToolDef, bool) {
 	tool, ok := r.tools[name]
@@ -62,8 +40,7 @@ func (r *ToolRegistry) Get(name string) (*ToolDef, bool) {
 // CallTool calls the given tool with the given arguments. It constructs the Tool request and decodes the Tool response
 func (r *ToolRegistry) CallTool(ctx context.Context, client api.Client, name string, args map[string]any) (map[string]json.RawMessage, error) {
 	tool := r.tools[name]
-	endpoint := r.endpoints[name]
-	resp, err := doToolCall(ctx, client, endpoint, tool.RawName, args)
+	resp, err := doToolCall(ctx, client, MCPURLPath, tool.RawName, args)
 	if err != nil {
 		return nil, err
 	}