fix(mcp-agent): stream native mcp-server stderr to logs

The previous implementation buffered stderr from the native mcp-server process and only logged the full buffer content when the process exited. This prevented real-time viewing of logs from the server.

This change modifies the native process startup logic (`startProcess_locked`) to use `cmd.StderrPipe()` instead of assigning `cmd.Stderr` to a buffer. A separate goroutine is now launched within the process monitoring goroutine. This new goroutine uses a `bufio.Scanner` to continuously read lines from the stderr pipe and logs them using the Navidrome logger (`log.Info`) with an `[MCP-SERVER]` prefix.

This ensures logs from the native mcp-server appear in Navidrome's logs immediately as they are written.

(Note: Also includes update to McpServerPath constant to point to the native binary.)

Signed-off-by: Deluan <deluan@navidrome.org>

core/agents/agents.go

@@ -45,7 +45,7 @@ func createAgents(ds model.DataStore) *Agents {
 			continue
 		}
 		enabled = append(enabled, name)
-		res = append(res, init(ds))
+		res = append(res, agent)
 	}
 	log.Debug("List of agents enabled", "names", enabled)
 

core/agents/mcp/mcp-server/.gitignore

@@ -0,0 +1,2 @@
+mcp-server
+*.wasm

core/agents/mcp/mcp-server/README.md

@@ -0,0 +1,17 @@
+# MCP Server (Proof of Concept)
+
+This directory contains the source code for the `mcp-server`, a simple server implementation used as a proof-of-concept (PoC) for the Navidrome Plugin/MCP agent system.
+
+This server is designed to be compiled into a WebAssembly (WASM) module (`.wasm`) using the `wasip1` target.
+
+## Compilation
+
+To compile the server into a WASM module (`mcp-server.wasm`), navigate to this directory in your terminal and run the following command:
+
+```bash
+CGO_ENABLED=0 GOOS=wasip1 GOARCH=wasm go build -o mcp-server.wasm .
+```
+
+**Note:** This command compiles the WASM module _without_ the `netgo` tag. Networking operations (like HTTP requests) are expected to be handled by host functions provided by the embedding application (Navidrome's `MCPAgent`) rather than directly within the WASM module itself.
+
+Place the resulting `mcp-server.wasm` file where the Navidrome `MCPAgent` expects it (currently configured via the `McpServerPath` constant in `core/agents/mcp/mcp_agent.go`).

core/agents/mcp/mcp-server/dbpedia.go

@@ -0,0 +1,172 @@
+package main
+
+import (
+	"context"
+	"encoding/json" // Reusing ErrNotFound from wikidata.go (implicitly via main)
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+const dbpediaEndpoint = "https://dbpedia.org/sparql"
+
+// Default timeout for DBpedia requests
+const defaultDbpediaTimeout = 20 * time.Second
+
+// Can potentially reuse SparqlResult, SparqlBindings, SparqlValue from wikidata.go
+// if the structure is identical. Assuming it is for now.
+
+// GetArtistBioFromDBpedia queries DBpedia for an artist's abstract using their name.
+func GetArtistBioFromDBpedia(fetcher Fetcher, ctx context.Context, name string) (string, error) {
+	log.Printf("[MCP] Debug: GetArtistBioFromDBpedia called for name: %s", name)
+	if name == "" {
+		log.Printf("[MCP] Error: GetArtistBioFromDBpedia requires a name.")
+		return "", fmt.Errorf("name is required to query DBpedia by name")
+	}
+
+	// Escape name for SPARQL query literal
+	escapedName := strings.ReplaceAll(name, "\"", "\\\"")
+
+	// SPARQL query using DBpedia ontology (dbo)
+	// Prefixes are recommended but can be omitted if endpoint resolves them.
+	// Searching case-insensitively on the label.
+	// Filtering for dbo:MusicalArtist or dbo:Band.
+	// Selecting the English abstract.
+	sparqlQuery := fmt.Sprintf(`
+PREFIX dbo: <http://dbpedia.org/ontology/>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+SELECT DISTINCT ?abstract WHERE {
+  ?artist rdfs:label ?nameLabel .
+  FILTER(LCASE(STR(?nameLabel)) = LCASE("%s") && LANG(?nameLabel) = "en")
+  
+  # Ensure it's a musical artist or band
+  { ?artist rdf:type dbo:MusicalArtist } UNION { ?artist rdf:type dbo:Band }
+  
+  ?artist dbo:abstract ?abstract .
+  FILTER(LANG(?abstract) = "en")
+} LIMIT 1`, escapedName)
+
+	// Prepare and execute HTTP request
+	queryValues := url.Values{}
+	queryValues.Set("query", sparqlQuery)
+	queryValues.Set("format", "application/sparql-results+json") // DBpedia standard format
+
+	reqURL := fmt.Sprintf("%s?%s", dbpediaEndpoint, queryValues.Encode())
+	log.Printf("[MCP] Debug: DBpedia Bio Request URL: %s", reqURL)
+
+	timeout := defaultDbpediaTimeout
+	if deadline, ok := ctx.Deadline(); ok {
+		timeout = time.Until(deadline)
+	}
+	log.Printf("[MCP] Debug: Fetching from DBpedia with timeout: %v", timeout)
+
+	statusCode, bodyBytes, err := fetcher.Fetch(ctx, "GET", reqURL, nil, timeout)
+	if err != nil {
+		log.Printf("[MCP] Error: Fetcher failed for DBpedia bio request (name: '%s'): %v", name, err)
+		return "", fmt.Errorf("failed to execute DBpedia request: %w", err)
+	}
+
+	if statusCode != http.StatusOK {
+		log.Printf("[MCP] Error: DBpedia bio query failed for name '%s' with status %d: %s", name, statusCode, string(bodyBytes))
+		return "", fmt.Errorf("DBpedia query failed with status %d: %s", statusCode, string(bodyBytes))
+	}
+	log.Printf("[MCP] Debug: DBpedia bio query successful (status %d), %d bytes received.", statusCode, len(bodyBytes))
+
+	var result SparqlResult
+	if err := json.Unmarshal(bodyBytes, &result); err != nil {
+		// Try reading the raw body for debugging if JSON parsing fails
+		// (Seek back to the beginning might be needed if already read for error)
+		// For simplicity, just return the parsing error now.
+		log.Printf("[MCP] Error: Failed to decode DBpedia bio response for name '%s': %v", name, err)
+		return "", fmt.Errorf("failed to decode DBpedia response: %w", err)
+	}
+
+	// Extract the abstract
+	if len(result.Results.Bindings) > 0 {
+		if abstractVal, ok := result.Results.Bindings[0]["abstract"]; ok {
+			log.Printf("[MCP] Debug: Found DBpedia abstract for '%s'.", name)
+			return abstractVal.Value, nil
+		}
+	}
+
+	// Use the shared ErrNotFound
+	log.Printf("[MCP] Warn: No abstract found on DBpedia for name '%s'.", name)
+	return "", ErrNotFound
+}
+
+// GetArtistWikipediaURLFromDBpedia queries DBpedia for an artist's Wikipedia URL using their name.
+func GetArtistWikipediaURLFromDBpedia(fetcher Fetcher, ctx context.Context, name string) (string, error) {
+	log.Printf("[MCP] Debug: GetArtistWikipediaURLFromDBpedia called for name: %s", name)
+	if name == "" {
+		log.Printf("[MCP] Error: GetArtistWikipediaURLFromDBpedia requires a name.")
+		return "", fmt.Errorf("name is required to query DBpedia by name for URL")
+	}
+
+	escapedName := strings.ReplaceAll(name, "\"", "\\\"")
+
+	// SPARQL query using foaf:isPrimaryTopicOf
+	sparqlQuery := fmt.Sprintf(`
+PREFIX dbo: <http://dbpedia.org/ontology/>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+
+SELECT DISTINCT ?wikiPage WHERE {
+  ?artist rdfs:label ?nameLabel .
+  FILTER(LCASE(STR(?nameLabel)) = LCASE("%s") && LANG(?nameLabel) = "en")
+
+  { ?artist rdf:type dbo:MusicalArtist } UNION { ?artist rdf:type dbo:Band }
+
+  ?artist foaf:isPrimaryTopicOf ?wikiPage .
+  # Ensure it links to the English Wikipedia
+  FILTER(STRSTARTS(STR(?wikiPage), "https://en.wikipedia.org/"))
+} LIMIT 1`, escapedName)
+
+	// Prepare and execute HTTP request (similar structure to bio query)
+	queryValues := url.Values{}
+	queryValues.Set("query", sparqlQuery)
+	queryValues.Set("format", "application/sparql-results+json")
+
+	reqURL := fmt.Sprintf("%s?%s", dbpediaEndpoint, queryValues.Encode())
+	log.Printf("[MCP] Debug: DBpedia URL Request URL: %s", reqURL)
+
+	timeout := defaultDbpediaTimeout
+	if deadline, ok := ctx.Deadline(); ok {
+		timeout = time.Until(deadline)
+	}
+	log.Printf("[MCP] Debug: Fetching DBpedia URL with timeout: %v", timeout)
+
+	statusCode, bodyBytes, err := fetcher.Fetch(ctx, "GET", reqURL, nil, timeout)
+	if err != nil {
+		log.Printf("[MCP] Error: Fetcher failed for DBpedia URL request (name: '%s'): %v", name, err)
+		return "", fmt.Errorf("failed to execute DBpedia URL request: %w", err)
+	}
+
+	if statusCode != http.StatusOK {
+		log.Printf("[MCP] Error: DBpedia URL query failed for name '%s' with status %d: %s", name, statusCode, string(bodyBytes))
+		return "", fmt.Errorf("DBpedia URL query failed with status %d: %s", statusCode, string(bodyBytes))
+	}
+	log.Printf("[MCP] Debug: DBpedia URL query successful (status %d), %d bytes received.", statusCode, len(bodyBytes))
+
+	var result SparqlResult
+	if err := json.Unmarshal(bodyBytes, &result); err != nil {
+		log.Printf("[MCP] Error: Failed to decode DBpedia URL response for name '%s': %v", name, err)
+		return "", fmt.Errorf("failed to decode DBpedia URL response: %w", err)
+	}
+
+	// Extract the URL
+	if len(result.Results.Bindings) > 0 {
+		if pageVal, ok := result.Results.Bindings[0]["wikiPage"]; ok {
+			log.Printf("[MCP] Debug: Found DBpedia Wikipedia URL for '%s': %s", name, pageVal.Value)
+			return pageVal.Value, nil
+		}
+	}
+
+	log.Printf("[MCP] Warn: No Wikipedia URL found on DBpedia for name '%s'.", name)
+	return "", ErrNotFound
+}

core/agents/mcp/mcp-server/fetch.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"context"
+	"time"
+)
+
+// Fetcher defines an interface for making HTTP requests, abstracting
+// over native net/http and WASM host functions.
+type Fetcher interface {
+	// Fetch performs an HTTP request.
+	// Returns the status code, response body, and any error encountered.
+	// Note: Implementations should aim to return the body even on non-2xx status codes
+	// if the body was successfully read, allowing callers to potentially inspect it.
+	Fetch(ctx context.Context, method, url string, requestBody []byte, timeout time.Duration) (statusCode int, responseBody []byte, err error)
+}

core/agents/mcp/mcp-server/fetch_native.go

@@ -0,0 +1,83 @@
+//go:build !wasm
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"time"
+)
+
+type nativeFetcher struct {
+	// We could hold a shared client, but creating one per request
+	// with the specific timeout is simpler for this adapter.
+}
+
+// Ensure nativeFetcher implements Fetcher
+var _ Fetcher = (*nativeFetcher)(nil)
+
+// NewFetcher creates the default native HTTP fetcher.
+func NewFetcher() Fetcher {
+	log.Println("[MCP] Debug: Using Native HTTP fetcher")
+	return &nativeFetcher{}
+}
+
+func (nf *nativeFetcher) Fetch(ctx context.Context, method, urlStr string, requestBody []byte, timeout time.Duration) (statusCode int, responseBody []byte, err error) {
+	log.Printf("[MCP] Debug: Native Fetch: Method=%s, URL=%s, Timeout=%v", method, urlStr, timeout)
+	// Create a client with the specific timeout for this request
+	client := &http.Client{Timeout: timeout}
+
+	var bodyReader io.Reader
+	if requestBody != nil {
+		bodyReader = bytes.NewReader(requestBody)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, method, urlStr, bodyReader)
+	if err != nil {
+		log.Printf("[MCP] Error: Native Fetch failed to create request: %v", err)
+		return 0, nil, fmt.Errorf("failed to create native request: %w", err)
+	}
+
+	// Set headers consistent with previous direct client usage
+	req.Header.Set("Accept", "application/sparql-results+json, application/json")
+	// Note: Specific User-Agent was set per call site previously, might need adjustment
+	// if different user agents are desired per service.
+	req.Header.Set("User-Agent", "MCPGoServerExample/0.1 (Native Client)")
+
+	log.Printf("[MCP] Debug: Native Fetch executing request...")
+	resp, err := client.Do(req)
+	if err != nil {
+		// Let context cancellation errors pass through
+		if ctx.Err() != nil {
+			log.Printf("[MCP] Debug: Native Fetch context cancelled: %v", ctx.Err())
+			return 0, nil, ctx.Err()
+		}
+		log.Printf("[MCP] Error: Native Fetch HTTP request failed: %v", err)
+		return 0, nil, fmt.Errorf("native HTTP request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	statusCode = resp.StatusCode
+	log.Printf("[MCP] Debug: Native Fetch received status code: %d", statusCode)
+	responseBodyBytes, readErr := io.ReadAll(resp.Body)
+	if readErr != nil {
+		// Still return status code if body read fails
+		log.Printf("[MCP] Error: Native Fetch failed to read response body: %v", readErr)
+		return statusCode, nil, fmt.Errorf("failed to read native response body: %w", readErr)
+	}
+	responseBody = responseBodyBytes
+	log.Printf("[MCP] Debug: Native Fetch read %d bytes from response body", len(responseBodyBytes))
+
+	// Mimic behavior of returning body even on error status
+	if statusCode < 200 || statusCode >= 300 {
+		log.Printf("[MCP] Warn: Native Fetch request failed with status %d. Body: %s", statusCode, string(responseBody))
+		return statusCode, responseBody, fmt.Errorf("native request failed with status %d", statusCode)
+	}
+
+	log.Printf("[MCP] Debug: Native Fetch completed successfully.")
+	return statusCode, responseBody, nil
+}

core/agents/mcp/mcp-server/fetch_wasm.go

@@ -0,0 +1,171 @@
+//go:build wasm
+
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"time"
+	"unsafe"
+)
+
+// --- WASM Host Function Import --- (Copied from user prompt)
+
+//go:wasmimport env http_fetch
+//go:noescape
+func http_fetch(
+	// Request details
+	urlPtr, urlLen uint32,
+	methodPtr, methodLen uint32,
+	bodyPtr, bodyLen uint32,
+	timeoutMillis uint32,
+	// Result pointers
+	resultStatusPtr uint32,
+	resultBodyPtr uint32, resultBodyCapacity uint32, resultBodyLenPtr uint32,
+	resultErrorPtr uint32, resultErrorCapacity uint32, resultErrorLenPtr uint32,
+) uint32 // 0 on success, 1 on host error
+
+// --- Go Wrapper for Host Function --- (Copied from user prompt)
+
+const (
+	defaultResponseBodyCapacity  = 1024 * 10 // 10 KB for response body
+	defaultResponseErrorCapacity = 1024      // 1 KB for error messages
+)
+
+// callHostHTTPFetch provides a Go-friendly interface to the http_fetch host function.
+func callHostHTTPFetch(ctx context.Context, method, url string, requestBody []byte, timeout time.Duration) (statusCode int, responseBody []byte, err error) {
+	log.Printf("[MCP] Debug: WASM Fetch (Host Call): Method=%s, URL=%s, Timeout=%v", method, url, timeout)
+
+	// --- Prepare Input Pointers ---
+	urlPtr, urlLen := stringToPtr(url)
+	methodPtr, methodLen := stringToPtr(method)
+	bodyPtr, bodyLen := bytesToPtr(requestBody)
+
+	timeoutMillis := uint32(timeout.Milliseconds())
+	if timeoutMillis <= 0 {
+		timeoutMillis = 30000 // Default 30 seconds if 0 or negative
+	}
+	if timeout == 0 {
+		// Handle case where context might already be cancelled
+		select {
+		case <-ctx.Done():
+			log.Printf("[MCP] Debug: WASM Fetch context cancelled before host call: %v", ctx.Err())
+			return 0, nil, ctx.Err()
+		default:
+		}
+	}
+
+	// --- Prepare Output Buffers and Pointers ---
+	resultBodyBuffer := make([]byte, defaultResponseBodyCapacity)
+	resultErrorBuffer := make([]byte, defaultResponseErrorCapacity)
+
+	resultStatus := uint32(0)
+	resultBodyLen := uint32(0)
+	resultErrorLen := uint32(0)
+
+	resultStatusPtr := &resultStatus
+	resultBodyPtr, resultBodyCapacity := bytesToPtr(resultBodyBuffer)
+	resultBodyLenPtr := &resultBodyLen
+	resultErrorPtr, resultErrorCapacity := bytesToPtr(resultErrorBuffer)
+	resultErrorLenPtr := &resultErrorLen
+
+	// --- Call the Host Function ---
+	log.Printf("[MCP] Debug: WASM Fetch calling host function http_fetch...")
+	hostReturnCode := http_fetch(
+		urlPtr, urlLen,
+		methodPtr, methodLen,
+		bodyPtr, bodyLen,
+		timeoutMillis,
+		uint32(uintptr(unsafe.Pointer(resultStatusPtr))),
+		resultBodyPtr, resultBodyCapacity, uint32(uintptr(unsafe.Pointer(resultBodyLenPtr))),
+		resultErrorPtr, resultErrorCapacity, uint32(uintptr(unsafe.Pointer(resultErrorLenPtr))),
+	)
+	log.Printf("[MCP] Debug: WASM Fetch host function returned code: %d", hostReturnCode)
+
+	// --- Process Results ---
+	if hostReturnCode != 0 {
+		err = errors.New("host function http_fetch failed internally")
+		log.Printf("[MCP] Error: WASM Fetch host function failed: %v", err)
+		return 0, nil, err
+	}
+
+	statusCode = int(resultStatus)
+	log.Printf("[MCP] Debug: WASM Fetch received status code from host: %d", statusCode)
+
+	if resultErrorLen > 0 {
+		actualErrorLen := min(resultErrorLen, resultErrorCapacity)
+		errMsg := string(resultErrorBuffer[:actualErrorLen])
+		err = errors.New(errMsg)
+		log.Printf("[MCP] Error: WASM Fetch received error from host: %s", errMsg)
+		return statusCode, nil, err
+	}
+
+	if resultBodyLen > 0 {
+		actualBodyLen := min(resultBodyLen, resultBodyCapacity)
+		responseBody = make([]byte, actualBodyLen)
+		copy(responseBody, resultBodyBuffer[:actualBodyLen])
+		log.Printf("[MCP] Debug: WASM Fetch received %d bytes from host body (reported size: %d)", actualBodyLen, resultBodyLen)
+
+		if resultBodyLen > resultBodyCapacity {
+			err = fmt.Errorf("response body truncated: received %d bytes, but actual size was %d", actualBodyLen, resultBodyLen)
+			log.Printf("[MCP] Warn: WASM Fetch %v", err)
+			return statusCode, responseBody, err // Return truncated body with error
+		}
+		log.Printf("[MCP] Debug: WASM Fetch completed successfully.")
+		return statusCode, responseBody, nil
+	}
+
+	log.Printf("[MCP] Debug: WASM Fetch completed successfully (no body, no error).")
+	return statusCode, nil, nil
+}
+
+// --- Pointer Helper Functions --- (Copied from user prompt)
+
+func stringToPtr(s string) (ptr uint32, length uint32) {
+	if len(s) == 0 {
+		return 0, 0
+	}
+	// Use unsafe.StringData for potentially safer pointer access in modern Go
+	// Needs Go 1.20+
+	// return uint32(uintptr(unsafe.Pointer(unsafe.StringData(s)))), uint32(len(s))
+	// Fallback to slice conversion for broader compatibility / if StringData isn't available
+	buf := []byte(s)
+	return bytesToPtr(buf)
+}
+
+func bytesToPtr(b []byte) (ptr uint32, length uint32) {
+	if len(b) == 0 {
+		return 0, 0
+	}
+	// Use unsafe.SliceData for potentially safer pointer access in modern Go
+	// Needs Go 1.20+
+	// return uint32(uintptr(unsafe.Pointer(unsafe.SliceData(b)))), uint32(len(b))
+	// Fallback for broader compatibility
+	return uint32(uintptr(unsafe.Pointer(&b[0]))), uint32(len(b))
+}
+
+func min(a, b uint32) uint32 {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// --- WASM Fetcher Implementation ---
+type wasmFetcher struct{}
+
+// Ensure wasmFetcher implements Fetcher
+var _ Fetcher = (*wasmFetcher)(nil)
+
+// NewFetcher creates the WASM host function fetcher.
+func NewFetcher() Fetcher {
+	log.Println("[MCP] Debug: Using WASM host fetcher")
+	return &wasmFetcher{}
+}
+
+func (wf *wasmFetcher) Fetch(ctx context.Context, method, url string, requestBody []byte, timeout time.Duration) (statusCode int, responseBody []byte, err error) {
+	// Directly call the wrapper which now contains logging
+	return callHostHTTPFetch(ctx, method, url, requestBody, timeout)
+}

core/agents/mcp/mcp-server/go.mod

@@ -0,0 +1,19 @@
+module mcp-server
+
+go 1.24.2
+
+require github.com/metoro-io/mcp-golang v0.11.0
+
+require (
+	github.com/bahlo/generic-list-go v0.2.0 // indirect
+	github.com/buger/jsonparser v1.1.1 // indirect
+	github.com/invopop/jsonschema v0.12.0 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/tidwall/gjson v1.18.0 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
+	github.com/tidwall/sjson v1.2.5 // indirect
+	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

core/agents/mcp/mcp-server/go.sum

@@ -0,0 +1,34 @@
+github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
+github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
+github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
+github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/invopop/jsonschema v0.12.0 h1:6ovsNSuvn9wEQVOyc72aycBMVQFKz7cPdMJn10CvzRI=
+github.com/invopop/jsonschema v0.12.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/metoro-io/mcp-golang v0.11.0 h1:1k+VSE9QaeMTLn0gJ3FgE/DcjsCBsLFnz5eSFbgXUiI=
+github.com/metoro-io/mcp-golang v0.11.0/go.mod h1:ifLP9ZzKpN1UqFWNTpAHOqSvNkMK6b7d1FSZ5Lu0lN0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+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/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
+github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
+github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
+github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc=
+github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

core/agents/mcp/mcp-server/main.go

@@ -0,0 +1,289 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+
+	mcp_golang "github.com/metoro-io/mcp-golang"
+	"github.com/metoro-io/mcp-golang/transport/stdio"
+)
+
+type Content struct {
+	Title       string  `json:"title" jsonschema:"required,description=The title to submit"`
+	Description *string `json:"description" jsonschema:"description=The description to submit"`
+}
+type MyFunctionsArguments struct {
+	Submitter string  `json:"submitter" jsonschema:"required,description=The name of the thing calling this tool (openai, google, claude, etc)"`
+	Content   Content `json:"content" jsonschema:"required,description=The content of the message"`
+}
+
+type ArtistBiography struct {
+	ID   string `json:"id" jsonschema:"required,description=The id of the artist"`
+	Name string `json:"name" jsonschema:"required,description=The name of the artist"`
+	MBID string `json:"mbid" jsonschema:"description=The mbid of the artist"`
+}
+
+type ArtistURLArgs struct {
+	ID   string `json:"id" jsonschema:"required,description=The id of the artist"`
+	Name string `json:"name" jsonschema:"required,description=The name of the artist"`
+	MBID string `json:"mbid" jsonschema:"description=The mbid of the artist"`
+}
+
+func main() {
+	log.Println("[MCP] Starting mcp-server...")
+	done := make(chan struct{})
+
+	// Create the appropriate fetcher (native or WASM based on build tags)
+	log.Printf("[MCP] Debug: Creating fetcher...")
+	fetcher := NewFetcher()
+	log.Printf("[MCP] Debug: Fetcher created successfully.")
+
+	// --- Command Line Flag Handling ---
+	nameFlag := flag.String("name", "", "Artist name to query directly")
+	mbidFlag := flag.String("mbid", "", "Artist MBID to query directly")
+	flag.Parse()
+
+	if *nameFlag != "" || *mbidFlag != "" {
+		log.Printf("[MCP] Debug: Running tools directly via CLI flags (Name: '%s', MBID: '%s')", *nameFlag, *mbidFlag)
+		fmt.Println("--- Running Tools Directly ---")
+
+		// Call getArtistBiography
+		fmt.Printf("Calling get_artist_biography (Name: '%s', MBID: '%s')...\n", *nameFlag, *mbidFlag)
+		if *mbidFlag == "" && *nameFlag == "" {
+			fmt.Println("  Error: --mbid or --name is required for get_artist_biography")
+		} else {
+			// Use context.Background for CLI calls
+			log.Printf("[MCP] Debug: CLI calling getArtistBiography...")
+			bio, bioErr := getArtistBiography(fetcher, context.Background(), "cli", *nameFlag, *mbidFlag)
+			if bioErr != nil {
+				fmt.Printf("  Error: %v\n", bioErr)
+				log.Printf("[MCP] Error: CLI getArtistBiography failed: %v", bioErr)
+			} else {
+				fmt.Printf("  Result: %s\n", bio)
+				log.Printf("[MCP] Debug: CLI getArtistBiography succeeded.")
+			}
+		}
+
+		// Call getArtistURL
+		fmt.Printf("Calling get_artist_url (Name: '%s', MBID: '%s')...\n", *nameFlag, *mbidFlag)
+		if *mbidFlag == "" && *nameFlag == "" {
+			fmt.Println("  Error: --mbid or --name is required for get_artist_url")
+		} else {
+			log.Printf("[MCP] Debug: CLI calling getArtistURL...")
+			urlResult, urlErr := getArtistURL(fetcher, context.Background(), "cli", *nameFlag, *mbidFlag)
+			if urlErr != nil {
+				fmt.Printf("  Error: %v\n", urlErr)
+				log.Printf("[MCP] Error: CLI getArtistURL failed: %v", urlErr)
+			} else {
+				fmt.Printf("  Result: %s\n", urlResult)
+				log.Printf("[MCP] Debug: CLI getArtistURL succeeded.")
+			}
+		}
+
+		fmt.Println("-----------------------------")
+		log.Printf("[MCP] Debug: CLI execution finished.")
+		return // Exit after direct execution
+	}
+	// --- End Command Line Flag Handling ---
+
+	log.Printf("[MCP] Debug: Initializing MCP server...")
+	server := mcp_golang.NewServer(stdio.NewStdioServerTransport())
+
+	log.Printf("[MCP] Debug: Registering tool 'hello'...")
+	err := server.RegisterTool("hello", "Say hello to a person", func(arguments MyFunctionsArguments) (*mcp_golang.ToolResponse, error) {
+		log.Printf("[MCP] Debug: Tool 'hello' called with args: %+v", arguments)
+		return mcp_golang.NewToolResponse(mcp_golang.NewTextContent(fmt.Sprintf("Hello, %server!", arguments.Submitter))), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register tool 'hello': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering tool 'get_artist_biography'...")
+	err = server.RegisterTool("get_artist_biography", "Get the biography of an artist", func(arguments ArtistBiography) (*mcp_golang.ToolResponse, error) {
+		log.Printf("[MCP] Debug: Tool 'get_artist_biography' called with args: %+v", arguments)
+		// Using background context in handlers as request context isn't passed through MCP library currently
+		bio, err := getArtistBiography(fetcher, context.Background(), arguments.ID, arguments.Name, arguments.MBID)
+		if err != nil {
+			log.Printf("[MCP] Error: getArtistBiography handler failed: %v", err)
+			return nil, fmt.Errorf("handler returned an error: %w", err) // Return structured error
+		}
+		log.Printf("[MCP] Debug: Tool 'get_artist_biography' succeeded.")
+		return mcp_golang.NewToolResponse(mcp_golang.NewTextContent(bio)), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register tool 'get_artist_biography': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering tool 'get_artist_url'...")
+	err = server.RegisterTool("get_artist_url", "Get the artist's specific Wikipedia URL via MBID, or a search URL using name as fallback", func(arguments ArtistURLArgs) (*mcp_golang.ToolResponse, error) {
+		log.Printf("[MCP] Debug: Tool 'get_artist_url' called with args: %+v", arguments)
+		urlResult, err := getArtistURL(fetcher, context.Background(), arguments.ID, arguments.Name, arguments.MBID)
+		if err != nil {
+			log.Printf("[MCP] Error: getArtistURL handler failed: %v", err)
+			return nil, fmt.Errorf("handler returned an error: %w", err)
+		}
+		log.Printf("[MCP] Debug: Tool 'get_artist_url' succeeded.")
+		return mcp_golang.NewToolResponse(mcp_golang.NewTextContent(urlResult)), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register tool 'get_artist_url': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering prompt 'prompt_test'...")
+	err = server.RegisterPrompt("prompt_test", "This is a test prompt", func(arguments Content) (*mcp_golang.PromptResponse, error) {
+		log.Printf("[MCP] Debug: Prompt 'prompt_test' called with args: %+v", arguments)
+		return mcp_golang.NewPromptResponse("description", mcp_golang.NewPromptMessage(mcp_golang.NewTextContent(fmt.Sprintf("Hello, %server!", arguments.Title)), mcp_golang.RoleUser)), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register prompt 'prompt_test': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering resource 'test://resource'...")
+	err = server.RegisterResource("test://resource", "resource_test", "This is a test resource", "application/json", func() (*mcp_golang.ResourceResponse, error) {
+		log.Printf("[MCP] Debug: Resource 'test://resource' called")
+		return mcp_golang.NewResourceResponse(mcp_golang.NewTextEmbeddedResource("test://resource", "This is a test resource", "application/json")), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register resource 'test://resource': %v", err)
+	}
+
+	log.Printf("[MCP] Debug: Registering resource 'file://app_logs'...")
+	err = server.RegisterResource("file://app_logs", "app_logs", "The app logs", "text/plain", func() (*mcp_golang.ResourceResponse, error) {
+		log.Printf("[MCP] Debug: Resource 'file://app_logs' called")
+		return mcp_golang.NewResourceResponse(mcp_golang.NewTextEmbeddedResource("file://app_logs", "This is a test resource", "text/plain")), nil
+	})
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Failed to register resource 'file://app_logs': %v", err)
+	}
+
+	log.Println("[MCP] MCP server initialized and starting to serve...")
+	err = server.Serve()
+	if err != nil {
+		log.Fatalf("[MCP] Fatal: Server exited with error: %v", err)
+	}
+
+	log.Println("[MCP] Server exited cleanly.")
+	<-done // Keep running until interrupted (though server.Serve() is blocking)
+}
+
+func getArtistBiography(fetcher Fetcher, ctx context.Context, id, name, mbid string) (string, error) {
+	log.Printf("[MCP] Debug: getArtistBiography called (id: %s, name: %s, mbid: %s)", id, name, mbid)
+	if mbid == "" {
+		fmt.Fprintf(os.Stderr, "MBID not provided, attempting DBpedia lookup by name: %s\n", name)
+		log.Printf("[MCP] Debug: MBID not provided, attempting DBpedia lookup by name: %s", name)
+	} else {
+		// 1. Attempt Wikidata MBID lookup first
+		log.Printf("[MCP] Debug: Attempting Wikidata URL lookup for MBID: %s", mbid)
+		wikiURL, err := GetArtistWikipediaURL(fetcher, ctx, mbid)
+		if err == nil {
+			// 1a. Found Wikidata URL, now fetch from Wikipedia API
+			log.Printf("[MCP] Debug: Found Wikidata URL '%s', fetching bio from Wikipedia API...", wikiURL)
+			bio, errBio := GetBioFromWikipediaAPI(fetcher, ctx, wikiURL)
+			if errBio == nil {
+				log.Printf("[MCP] Debug: Successfully fetched bio from Wikipedia API for '%s'.", name)
+				return bio, nil // Success via Wikidata/Wikipedia!
+			} else {
+				// Failed to get bio even though URL was found
+				log.Printf("[MCP] Error: Found Wikipedia URL (%s) via MBID %s, but failed to fetch bio: %v", wikiURL, mbid, errBio)
+				fmt.Fprintf(os.Stderr, "Found Wikipedia URL (%s) via MBID %s, but failed to fetch bio: %v\n", wikiURL, mbid, errBio)
+				// Fall through to try DBpedia by name as a last resort?
+				// Let's fall through for now.
+			}
+		} else if !errors.Is(err, ErrNotFound) {
+			// Wikidata lookup failed for a reason other than not found (e.g., network)
+			log.Printf("[MCP] Error: Wikidata URL lookup failed for MBID %s (non-NotFound error): %v", mbid, err)
+			fmt.Fprintf(os.Stderr, "Wikidata URL lookup failed for MBID %s (non-NotFound error): %v\n", mbid, err)
+			// Don't proceed to DBpedia name lookup if Wikidata had a technical failure
+			return "", fmt.Errorf("Wikidata lookup failed: %w", err)
+		} else {
+			// Wikidata lookup returned ErrNotFound for MBID
+			log.Printf("[MCP] Debug: MBID %s not found on Wikidata, attempting DBpedia lookup by name: %s", mbid, name)
+			fmt.Fprintf(os.Stderr, "MBID %s not found on Wikidata, attempting DBpedia lookup by name: %s\n", mbid, name)
+		}
+	}
+
+	// 2. Attempt DBpedia lookup by name (if MBID was missing or failed with ErrNotFound)
+	if name == "" {
+		log.Printf("[MCP] Error: Cannot find artist bio: MBID lookup failed/missing, and no name provided.")
+		return "", fmt.Errorf("cannot find artist: MBID lookup failed or MBID not provided, and no name provided for DBpedia fallback")
+	}
+	log.Printf("[MCP] Debug: Attempting DBpedia bio lookup by name: %s", name)
+	dbpediaBio, errDb := GetArtistBioFromDBpedia(fetcher, ctx, name)
+	if errDb == nil {
+		log.Printf("[MCP] Debug: Successfully fetched bio from DBpedia for '%s'.", name)
+		return dbpediaBio, nil // Success via DBpedia!
+	}
+
+	// 3. If both Wikidata (MBID) and DBpedia (Name) failed
+	if errors.Is(errDb, ErrNotFound) {
+		log.Printf("[MCP] Error: Artist '%s' (MBID: %s) not found via Wikidata or DBpedia name lookup.", name, mbid)
+		return "", fmt.Errorf("artist '%s' (MBID: %s) not found via Wikidata MBID or DBpedia Name lookup", name, mbid)
+	}
+
+	// Return DBpedia's error if it wasn't ErrNotFound
+	log.Printf("[MCP] Error: DBpedia lookup failed for name '%s': %v", name, errDb)
+	return "", fmt.Errorf("DBpedia lookup failed for name '%s': %w", name, errDb)
+}
+
+// getArtistURL attempts to find the specific Wikipedia URL using MBID (via Wikidata),
+// then by Name (via DBpedia), falling back to a search URL using name.
+func getArtistURL(fetcher Fetcher, ctx context.Context, id, name, mbid string) (string, error) {
+	log.Printf("[MCP] Debug: getArtistURL called (id: %s, name: %s, mbid: %s)", id, name, mbid)
+	if mbid == "" {
+		fmt.Fprintf(os.Stderr, "getArtistURL: MBID not provided, attempting DBpedia lookup by name: %s\n", name)
+		log.Printf("[MCP] Debug: getArtistURL: MBID not provided, attempting DBpedia lookup by name: %s", name)
+	} else {
+		// Try to get the specific URL from Wikidata using MBID
+		log.Printf("[MCP] Debug: getArtistURL: Attempting Wikidata URL lookup for MBID: %s", mbid)
+		wikiURL, err := GetArtistWikipediaURL(fetcher, ctx, mbid)
+		if err == nil && wikiURL != "" {
+			log.Printf("[MCP] Debug: getArtistURL: Found specific URL '%s' via Wikidata MBID.", wikiURL)
+			return wikiURL, nil // Found specific URL via MBID
+		}
+		// Log error if Wikidata lookup failed for reasons other than not found
+		if err != nil && !errors.Is(err, ErrNotFound) {
+			log.Printf("[MCP] Error: getArtistURL: Wikidata URL lookup failed for MBID %s (non-NotFound error): %v", mbid, err)
+			fmt.Fprintf(os.Stderr, "getArtistURL: Wikidata URL lookup failed for MBID %s (non-NotFound error): %v\n", mbid, err)
+			// Fall through to try DBpedia if name is available
+		} else if errors.Is(err, ErrNotFound) {
+			log.Printf("[MCP] Debug: getArtistURL: MBID %s not found on Wikidata, attempting DBpedia lookup by name: %s", mbid, name)
+			fmt.Fprintf(os.Stderr, "getArtistURL: MBID %s not found on Wikidata, attempting DBpedia lookup by name: %s\n", mbid, name)
+		}
+	}
+
+	// Fallback 1: Try DBpedia lookup by name
+	if name != "" {
+		log.Printf("[MCP] Debug: getArtistURL: Attempting DBpedia URL lookup by name: %s", name)
+		dbpediaWikiURL, errDb := GetArtistWikipediaURLFromDBpedia(fetcher, ctx, name)
+		if errDb == nil && dbpediaWikiURL != "" {
+			log.Printf("[MCP] Debug: getArtistURL: Found specific URL '%s' via DBpedia Name lookup.", dbpediaWikiURL)
+			return dbpediaWikiURL, nil // Found specific URL via DBpedia Name lookup
+		}
+		// Log error if DBpedia lookup failed for reasons other than not found
+		if errDb != nil && !errors.Is(errDb, ErrNotFound) {
+			log.Printf("[MCP] Error: getArtistURL: DBpedia URL lookup failed for name '%s' (non-NotFound error): %v", name, errDb)
+			fmt.Fprintf(os.Stderr, "getArtistURL: DBpedia URL lookup failed for name '%s' (non-NotFound error): %v\n", name, errDb)
+			// Fall through to search URL fallback
+		} else if errors.Is(errDb, ErrNotFound) {
+			log.Printf("[MCP] Debug: getArtistURL: Name '%s' not found on DBpedia, attempting search fallback", name)
+			fmt.Fprintf(os.Stderr, "getArtistURL: Name '%s' not found on DBpedia, attempting search fallback\n", name)
+		}
+	}
+
+	// Fallback 2: Generate a search URL if name is provided
+	if name != "" {
+		searchURL := fmt.Sprintf("https://en.wikipedia.org/w/index.php?search=%s", url.QueryEscape(name))
+		log.Printf("[MCP] Debug: getArtistURL: Falling back to search URL: %s", searchURL)
+		fmt.Fprintf(os.Stderr, "getArtistURL: Falling back to search URL: %s\n", searchURL)
+		return searchURL, nil
+	}
+
+	// Final error: MBID lookup failed (or no MBID given) AND no name provided for fallback
+	log.Printf("[MCP] Error: getArtistURL: Cannot generate Wikipedia URL: Lookups failed and no name provided.")
+	return "", fmt.Errorf("cannot generate Wikipedia URL: Wikidata/DBpedia lookups failed and no artist name provided for search fallback")
+}

core/agents/mcp/mcp-server/wikidata.go

@@ -0,0 +1,205 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"time"
+)
+
+const wikidataEndpoint = "https://query.wikidata.org/sparql"
+
+// ErrNotFound indicates a specific item (like an artist or URL) was not found on Wikidata.
+var ErrNotFound = errors.New("item not found on Wikidata")
+
+// Wikidata SPARQL query result structures
+type SparqlResult struct {
+	Results SparqlBindings `json:"results"`
+}
+
+type SparqlBindings struct {
+	Bindings []map[string]SparqlValue `json:"bindings"`
+}
+
+type SparqlValue struct {
+	Type  string `json:"type"`
+	Value string `json:"value"`
+	Lang  string `json:"xml:lang,omitempty"` // Handle language tags like "en"
+}
+
+// GetArtistBioFromWikidata queries Wikidata for an artist's description using their MBID.
+// NOTE: This function is currently UNUSED as the main logic prefers Wikipedia/DBpedia.
+func GetArtistBioFromWikidata(client *http.Client, mbid string) (string, error) {
+	log.Printf("[MCP] Debug: GetArtistBioFromWikidata called for MBID: %s", mbid)
+	if mbid == "" {
+		log.Printf("[MCP] Error: GetArtistBioFromWikidata requires an MBID.")
+		return "", fmt.Errorf("MBID is required to query Wikidata")
+	}
+
+	// SPARQL query to find the English description for an entity with a specific MusicBrainz ID
+	sparqlQuery := fmt.Sprintf(`
+SELECT ?artistDescription WHERE {
+  ?artist wdt:P434 "%s" . # P434 is the property for MusicBrainz artist ID
+  OPTIONAL { 
+    ?artist schema:description ?artistDescription .
+    FILTER(LANG(?artistDescription) = "en")
+  }
+  SERVICE wikibase:label { bd:serviceParam wikibase:language "en". }
+}
+LIMIT 1`, mbid)
+
+	// Prepare the HTTP request
+	queryValues := url.Values{}
+	queryValues.Set("query", sparqlQuery)
+	queryValues.Set("format", "json")
+
+	reqURL := fmt.Sprintf("%s?%s", wikidataEndpoint, queryValues.Encode())
+	log.Printf("[MCP] Debug: Wikidata Bio Request URL: %s", reqURL)
+
+	req, err := http.NewRequest("GET", reqURL, nil)
+	if err != nil {
+		log.Printf("[MCP] Error: Failed to create Wikidata bio request: %v", err)
+		return "", fmt.Errorf("failed to create Wikidata request: %w", err)
+	}
+	req.Header.Set("Accept", "application/sparql-results+json")
+	req.Header.Set("User-Agent", "MCPGoServerExample/0.1 (https://example.com/contact)") // Good practice to identify your client
+
+	// Execute the request
+	log.Printf("[MCP] Debug: Executing Wikidata bio request...")
+	resp, err := client.Do(req)
+	if err != nil {
+		log.Printf("[MCP] Error: Failed to execute Wikidata bio request: %v", err)
+		return "", fmt.Errorf("failed to execute Wikidata request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		// Attempt to read body for more error info, but don't fail if it doesn't work
+		bodyBytes, readErr := io.ReadAll(resp.Body)
+		errorMsg := "Could not read error body"
+		if readErr == nil {
+			errorMsg = string(bodyBytes)
+		}
+		log.Printf("[MCP] Error: Wikidata bio query failed with status %d: %s", resp.StatusCode, errorMsg)
+		return "", fmt.Errorf("Wikidata query failed with status %d: %s", resp.StatusCode, errorMsg)
+	}
+	log.Printf("[MCP] Debug: Wikidata bio query successful (status %d).", resp.StatusCode)
+
+	// Parse the response
+	var result SparqlResult
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		log.Printf("[MCP] Error: Failed to decode Wikidata bio response: %v", err)
+		return "", fmt.Errorf("failed to decode Wikidata response: %w", err)
+	}
+
+	// Extract the description
+	if len(result.Results.Bindings) > 0 {
+		if descriptionVal, ok := result.Results.Bindings[0]["artistDescription"]; ok {
+			log.Printf("[MCP] Debug: Found description for MBID %s", mbid)
+			return descriptionVal.Value, nil
+		}
+	}
+
+	log.Printf("[MCP] Warn: No English description found on Wikidata for MBID %s", mbid)
+	return "", fmt.Errorf("no English description found on Wikidata for MBID %s", mbid)
+}
+
+// GetArtistWikipediaURL queries Wikidata for an artist's English Wikipedia page URL using MBID.
+// It tries searching by MBID first, then falls back to searching by name.
+func GetArtistWikipediaURL(fetcher Fetcher, ctx context.Context, mbid string) (string, error) {
+	log.Printf("[MCP] Debug: GetArtistWikipediaURL called for MBID: %s", mbid)
+	// 1. Try finding by MBID
+	if mbid == "" {
+		log.Printf("[MCP] Error: GetArtistWikipediaURL requires an MBID.")
+		return "", fmt.Errorf("MBID is required to find Wikipedia URL on Wikidata")
+	} else {
+		// SPARQL query to find the enwiki URL for an entity with a specific MusicBrainz ID
+		sparqlQuery := fmt.Sprintf(`
+SELECT ?article WHERE {
+  ?artist wdt:P434 "%s" . # P434 is MusicBrainz artist ID
+  ?article schema:about ?artist ;
+           schema:isPartOf <https://en.wikipedia.org/> .
+}
+LIMIT 1`, mbid)
+
+		log.Printf("[MCP] Debug: Executing Wikidata URL query for MBID: %s", mbid)
+		foundURL, err := executeWikidataURLQuery(fetcher, ctx, sparqlQuery)
+		if err == nil && foundURL != "" {
+			log.Printf("[MCP] Debug: Found Wikipedia URL '%s' via MBID %s", foundURL, mbid)
+			return foundURL, nil // Found via MBID
+		}
+		// Use the specific ErrNotFound
+		if errors.Is(err, ErrNotFound) {
+			log.Printf("[MCP] Debug: MBID %s not found on Wikidata for URL lookup.", mbid)
+			return "", ErrNotFound // Explicitly return ErrNotFound
+		}
+		// Log other errors
+		if err != nil {
+			log.Printf("[MCP] Error: Wikidata URL lookup via MBID %s failed: %v", mbid, err)
+			fmt.Fprintf(os.Stderr, "Wikidata URL lookup via MBID %s failed: %v\n", mbid, err)
+			return "", fmt.Errorf("Wikidata URL lookup via MBID failed: %w", err)
+		}
+	}
+
+	// Should ideally not be reached if MBID is required and lookup failed or was not found
+	log.Printf("[MCP] Warn: Reached end of GetArtistWikipediaURL unexpectedly for MBID %s", mbid)
+	return "", ErrNotFound // Return ErrNotFound if somehow reached
+}
+
+// executeWikidataURLQuery is a helper to run SPARQL and extract the first bound URL for '?article'.
+func executeWikidataURLQuery(fetcher Fetcher, ctx context.Context, sparqlQuery string) (string, error) {
+	log.Printf("[MCP] Debug: executeWikidataURLQuery called.")
+	queryValues := url.Values{}
+	queryValues.Set("query", sparqlQuery)
+	queryValues.Set("format", "json")
+
+	reqURL := fmt.Sprintf("%s?%s", wikidataEndpoint, queryValues.Encode())
+	log.Printf("[MCP] Debug: Wikidata Sparql Request URL: %s", reqURL)
+
+	// Directly use the fetcher
+	// Note: Headers (Accept, User-Agent) are now handled by the Fetcher implementation
+	// The WASM fetcher currently doesn't support setting them via the host func interface.
+	// Timeout is handled via context for native, and passed to host func for WASM.
+	// Let's use a default timeout here if not provided via context (e.g., 15s)
+	// TODO: Consider making timeout configurable or passed down
+	timeout := 15 * time.Second
+	if deadline, ok := ctx.Deadline(); ok {
+		timeout = time.Until(deadline)
+	}
+	log.Printf("[MCP] Debug: Fetching from Wikidata with timeout: %v", timeout)
+
+	statusCode, bodyBytes, err := fetcher.Fetch(ctx, "GET", reqURL, nil, timeout)
+	if err != nil {
+		log.Printf("[MCP] Error: Fetcher failed for Wikidata SPARQL request: %v", err)
+		return "", fmt.Errorf("failed to execute Wikidata request: %w", err)
+	}
+
+	// Check status code. Fetcher interface implies body might be returned even on error.
+	if statusCode != http.StatusOK {
+		log.Printf("[MCP] Error: Wikidata SPARQL query failed with status %d: %s", statusCode, string(bodyBytes))
+		return "", fmt.Errorf("Wikidata query failed with status %d: %s", statusCode, string(bodyBytes))
+	}
+	log.Printf("[MCP] Debug: Wikidata SPARQL query successful (status %d), %d bytes received.", statusCode, len(bodyBytes))
+
+	var result SparqlResult
+	if err := json.Unmarshal(bodyBytes, &result); err != nil { // Use Unmarshal for byte slice
+		log.Printf("[MCP] Error: Failed to decode Wikidata SPARQL response: %v", err)
+		return "", fmt.Errorf("failed to decode Wikidata response: %w", err)
+	}
+
+	if len(result.Results.Bindings) > 0 {
+		if articleVal, ok := result.Results.Bindings[0]["article"]; ok {
+			log.Printf("[MCP] Debug: Found Wikidata article URL: %s", articleVal.Value)
+			return articleVal.Value, nil
+		}
+	}
+
+	log.Printf("[MCP] Debug: No Wikidata article URL found in SPARQL response.")
+	return "", ErrNotFound
+}

core/agents/mcp/mcp-server/wikipedia.go

@@ -0,0 +1,121 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+const mediaWikiAPIEndpoint = "https://en.wikipedia.org/w/api.php"
+
+// Structures for parsing MediaWiki API response (query extracts)
+type MediaWikiQueryResult struct {
+	Query MediaWikiQuery `json:"query"`
+}
+
+type MediaWikiQuery struct {
+	Pages map[string]MediaWikiPage `json:"pages"`
+}
+
+type MediaWikiPage struct {
+	PageID  int    `json:"pageid"`
+	Ns      int    `json:"ns"`
+	Title   string `json:"title"`
+	Extract string `json:"extract"`
+}
+
+// Default timeout for Wikipedia API requests
+const defaultWikipediaTimeout = 15 * time.Second
+
+// GetBioFromWikipediaAPI fetches the introductory text of a Wikipedia page.
+func GetBioFromWikipediaAPI(fetcher Fetcher, ctx context.Context, wikipediaURL string) (string, error) {
+	log.Printf("[MCP] Debug: GetBioFromWikipediaAPI called for URL: %s", wikipediaURL)
+	pageTitle, err := extractPageTitleFromURL(wikipediaURL)
+	if err != nil {
+		log.Printf("[MCP] Error: Could not extract title from Wikipedia URL '%s': %v", wikipediaURL, err)
+		return "", fmt.Errorf("could not extract title from Wikipedia URL %s: %w", wikipediaURL, err)
+	}
+	log.Printf("[MCP] Debug: Extracted Wikipedia page title: %s", pageTitle)
+
+	// Prepare API request parameters
+	apiParams := url.Values{}
+	apiParams.Set("action", "query")
+	apiParams.Set("format", "json")
+	apiParams.Set("prop", "extracts")    // Request page extracts
+	apiParams.Set("exintro", "true")     // Get only the intro section
+	apiParams.Set("explaintext", "true") // Get plain text instead of HTML
+	apiParams.Set("titles", pageTitle)   // Specify the page title
+	apiParams.Set("redirects", "1")      // Follow redirects
+
+	reqURL := fmt.Sprintf("%s?%s", mediaWikiAPIEndpoint, apiParams.Encode())
+	log.Printf("[MCP] Debug: MediaWiki API Request URL: %s", reqURL)
+
+	timeout := defaultWikipediaTimeout
+	if deadline, ok := ctx.Deadline(); ok {
+		timeout = time.Until(deadline)
+	}
+	log.Printf("[MCP] Debug: Fetching from MediaWiki with timeout: %v", timeout)
+
+	statusCode, bodyBytes, err := fetcher.Fetch(ctx, "GET", reqURL, nil, timeout)
+	if err != nil {
+		log.Printf("[MCP] Error: Fetcher failed for MediaWiki request (title: '%s'): %v", pageTitle, err)
+		return "", fmt.Errorf("failed to execute MediaWiki request for title '%s': %w", pageTitle, err)
+	}
+
+	if statusCode != http.StatusOK {
+		log.Printf("[MCP] Error: MediaWiki query for '%s' failed with status %d: %s", pageTitle, statusCode, string(bodyBytes))
+		return "", fmt.Errorf("MediaWiki query for '%s' failed with status %d: %s", pageTitle, statusCode, string(bodyBytes))
+	}
+	log.Printf("[MCP] Debug: MediaWiki query successful (status %d), %d bytes received.", statusCode, len(bodyBytes))
+
+	// Parse the response
+	var result MediaWikiQueryResult
+	if err := json.Unmarshal(bodyBytes, &result); err != nil {
+		log.Printf("[MCP] Error: Failed to decode MediaWiki response for '%s': %v", pageTitle, err)
+		return "", fmt.Errorf("failed to decode MediaWiki response for '%s': %w", pageTitle, err)
+	}
+
+	// Extract the text - MediaWiki API returns pages keyed by page ID
+	for pageID, page := range result.Query.Pages {
+		log.Printf("[MCP] Debug: Processing MediaWiki page ID: %s, Title: %s", pageID, page.Title)
+		if page.Extract != "" {
+			// Often includes a newline at the end, trim it
+			log.Printf("[MCP] Debug: Found extract for '%s'. Length: %d", pageTitle, len(page.Extract))
+			return strings.TrimSpace(page.Extract), nil
+		}
+	}
+
+	log.Printf("[MCP] Warn: No extract found in MediaWiki response for title '%s'", pageTitle)
+	return "", fmt.Errorf("no extract found in MediaWiki response for title '%s' (page might not exist or be empty)", pageTitle)
+}
+
+// extractPageTitleFromURL attempts to get the page title from a standard Wikipedia URL.
+// Example: https://en.wikipedia.org/wiki/The_Beatles -> The_Beatles
+func extractPageTitleFromURL(wikiURL string) (string, error) {
+	parsedURL, err := url.Parse(wikiURL)
+	if err != nil {
+		return "", err
+	}
+	if parsedURL.Host != "en.wikipedia.org" {
+		return "", fmt.Errorf("URL host is not en.wikipedia.org: %s", parsedURL.Host)
+	}
+	pathParts := strings.Split(strings.TrimPrefix(parsedURL.Path, "/"), "/")
+	if len(pathParts) < 2 || pathParts[0] != "wiki" {
+		return "", fmt.Errorf("URL path does not match /wiki/<title> format: %s", parsedURL.Path)
+	}
+	title := pathParts[1]
+	if title == "" {
+		return "", fmt.Errorf("extracted title is empty")
+	}
+	// URL Decode the title (e.g., %27 -> ')
+	decodedTitle, err := url.PathUnescape(title)
+	if err != nil {
+		return "", fmt.Errorf("failed to decode title '%s': %w", title, err)
+	}
+	return decodedTitle, nil
+}

core/agents/mcp/mcp_agent.go

@@ -0,0 +1,207 @@
+package mcp
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	mcp "github.com/metoro-io/mcp-golang"
+	"github.com/tetratelabs/wazero"
+
+	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+)
+
+// Constants used by the MCP agent
+const (
+	McpAgentName          = "mcp"
+	initializationTimeout = 5 * time.Second
+	// McpServerPath defines the location of the MCP server executable or WASM module.
+	// McpServerPath     = "./core/agents/mcp/mcp-server/mcp-server"
+	McpServerPath     = "./core/agents/mcp/mcp-server/mcp-server.wasm"
+	McpToolNameGetBio = "get_artist_biography"
+	McpToolNameGetURL = "get_artist_url"
+)
+
+// mcpClient interface matching the methods used from mcp.Client.
+type mcpClient interface {
+	Initialize(ctx context.Context) (*mcp.InitializeResponse, error)
+	CallTool(ctx context.Context, toolName string, args any) (*mcp.ToolResponse, error)
+}
+
+// mcpImplementation defines the common interface for both native and WASM MCP agents.
+// This allows the main MCPAgent to delegate calls without knowing the underlying type.
+type mcpImplementation interface {
+	Close() error // For cleaning up resources associated with this specific implementation.
+
+	// callMCPTool is the core method implemented differently by native/wasm
+	callMCPTool(ctx context.Context, toolName string, args any) (string, error)
+}
+
+// MCPAgent is the public-facing agent registered with Navidrome.
+// It acts as a wrapper around the actual implementation (native or WASM).
+type MCPAgent struct {
+	// No mutex needed here if impl is set once at construction
+	// and the implementation handles its own internal state synchronization.
+	impl mcpImplementation
+
+	// Shared Wazero resources (runtime, cache) are managed externally
+	// and closed separately, likely during application shutdown.
+}
+
+// mcpConstructor creates the appropriate MCP implementation (native or WASM)
+// and wraps it in the MCPAgent.
+func mcpConstructor(ds model.DataStore) agents.Interface {
+	if _, err := os.Stat(McpServerPath); os.IsNotExist(err) {
+		log.Warn("MCP server executable/WASM not found, disabling agent", "path", McpServerPath, "error", err)
+		return nil
+	}
+
+	var agentImpl mcpImplementation
+	var err error
+
+	if strings.HasSuffix(McpServerPath, ".wasm") {
+		log.Info("Configuring MCP agent for WASM execution", "path", McpServerPath)
+		ctx := context.Background()
+
+		// Setup Shared Wazero Resources
+		var cache wazero.CompilationCache
+		cacheDir := filepath.Join(conf.Server.DataFolder, "cache", "wazero")
+		if errMkdir := os.MkdirAll(cacheDir, 0755); errMkdir != nil {
+			log.Error(ctx, "Failed to create Wazero cache directory, WASM caching disabled", "path", cacheDir, "error", errMkdir)
+		} else {
+			cache, err = wazero.NewCompilationCacheWithDir(cacheDir)
+			if err != nil {
+				log.Error(ctx, "Failed to create Wazero compilation cache, WASM caching disabled", "path", cacheDir, "error", err)
+				cache = nil
+			}
+		}
+
+		runtimeConfig := wazero.NewRuntimeConfig()
+		if cache != nil {
+			runtimeConfig = runtimeConfig.WithCompilationCache(cache)
+		}
+
+		runtime := wazero.NewRuntimeWithConfig(ctx, runtimeConfig)
+
+		if err = registerHostFunctions(ctx, runtime); err != nil {
+			_ = runtime.Close(ctx)
+			if cache != nil {
+				_ = cache.Close(ctx)
+			}
+			return nil // Fatal error: Host functions required
+		}
+
+		if _, err = wasi_snapshot_preview1.Instantiate(ctx, runtime); err != nil {
+			log.Error(ctx, "Failed to instantiate WASI on shared Wazero runtime, MCP WASM agent disabled", "error", err)
+			_ = runtime.Close(ctx)
+			if cache != nil {
+				_ = cache.Close(ctx)
+			}
+			return nil // Fatal error: WASI required
+		}
+
+		// Compile the module
+		log.Debug(ctx, "Pre-compiling WASM module...", "path", McpServerPath)
+		wasmBytes, err := os.ReadFile(McpServerPath)
+		if err != nil {
+			log.Error(ctx, "Failed to read WASM module file, disabling agent", "path", McpServerPath, "error", err)
+			_ = runtime.Close(ctx)
+			if cache != nil {
+				_ = cache.Close(ctx)
+			}
+			return nil
+		}
+		compiledModule, err := runtime.CompileModule(ctx, wasmBytes)
+		if err != nil {
+			log.Error(ctx, "Failed to pre-compile WASM module, disabling agent", "path", McpServerPath, "error", err)
+			_ = runtime.Close(ctx)
+			if cache != nil {
+				_ = cache.Close(ctx)
+			}
+			return nil
+		}
+
+		agentImpl = newMCPWasm(runtime, cache, compiledModule)
+		log.Info(ctx, "Shared Wazero runtime, WASI, cache, host functions initialized, and module pre-compiled for MCP agent")
+
+	} else {
+		log.Info("Configuring MCP agent for native execution", "path", McpServerPath)
+		agentImpl = newMCPNative()
+	}
+
+	log.Info("MCP Agent implementation created successfully")
+	return &MCPAgent{impl: agentImpl}
+}
+
+// NewAgentForTesting is a constructor specifically for tests.
+// It creates the appropriate implementation based on McpServerPath
+// and injects a mock mcpClient into its ClientOverride field.
+func NewAgentForTesting(mockClient mcpClient) agents.Interface {
+	// We need to replicate the logic from mcpConstructor to determine
+	// the implementation type, but without actually starting processes.
+
+	var agentImpl mcpImplementation
+
+	if strings.HasSuffix(McpServerPath, ".wasm") {
+		// For WASM testing, we might not need the full runtime setup,
+		// just the struct. Pass nil for shared resources for now.
+		// We rely on the mockClient being used before any real WASM interaction.
+		wasmImpl := newMCPWasm(nil, nil, nil)
+		wasmImpl.ClientOverride = mockClient
+		agentImpl = wasmImpl
+	} else {
+		nativeImpl := newMCPNative()
+		nativeImpl.ClientOverride = mockClient
+		agentImpl = nativeImpl
+	}
+
+	return &MCPAgent{impl: agentImpl}
+}
+
+func (a *MCPAgent) AgentName() string {
+	return McpAgentName
+}
+
+func (a *MCPAgent) GetArtistBiography(ctx context.Context, id, name, mbid string) (string, error) {
+	if a.impl == nil {
+		return "", errors.New("MCP agent implementation is nil")
+	}
+	// Construct args and call the implementation's specific tool caller
+	args := ArtistArgs{ID: id, Name: name, Mbid: mbid}
+	return a.impl.callMCPTool(ctx, McpToolNameGetBio, args)
+}
+
+func (a *MCPAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
+	if a.impl == nil {
+		return "", errors.New("MCP agent implementation is nil")
+	}
+	// Construct args and call the implementation's specific tool caller
+	args := ArtistArgs{ID: id, Name: name, Mbid: mbid}
+	return a.impl.callMCPTool(ctx, McpToolNameGetURL, args)
+}
+
+// Note: A Close method on MCPAgent itself isn't part of agents.Interface.
+// Cleanup of the specific implementation happens via impl.Close().
+// Cleanup of shared Wazero resources needs separate handling (e.g., on app shutdown).
+
+// ArtistArgs defines the structure for MCP tool arguments requiring artist info.
+type ArtistArgs struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+	Mbid string `json:"mbid,omitempty"`
+}
+
+var _ agents.ArtistBiographyRetriever = (*MCPAgent)(nil)
+var _ agents.ArtistURLRetriever = (*MCPAgent)(nil)
+
+func init() {
+	agents.Register(McpAgentName, mcpConstructor)
+}

core/agents/mcp/mcp_agent_test.go

@@ -0,0 +1,237 @@
+package mcp_test
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+
+	mcp_client "github.com/metoro-io/mcp-golang" // Renamed alias for clarity
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/agents/mcp"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+// Define the mcpClient interface locally for mocking, matching the one
+// used internally by MCPNative/MCPWasm.
+type mcpClient interface {
+	Initialize(ctx context.Context) (*mcp_client.InitializeResponse, error)
+	CallTool(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error)
+}
+
+// mockMCPClient is a mock implementation of mcpClient for testing.
+type mockMCPClient struct {
+	InitializeFunc func(ctx context.Context) (*mcp_client.InitializeResponse, error)
+	CallToolFunc   func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error)
+	callToolArgs   []any  // Store args for verification
+	callToolName   string // Store tool name for verification
+}
+
+func (m *mockMCPClient) Initialize(ctx context.Context) (*mcp_client.InitializeResponse, error) {
+	if m.InitializeFunc != nil {
+		return m.InitializeFunc(ctx)
+	}
+	return &mcp_client.InitializeResponse{}, nil // Default success
+}
+
+func (m *mockMCPClient) CallTool(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+	m.callToolName = toolName
+	m.callToolArgs = append(m.callToolArgs, args)
+	if m.CallToolFunc != nil {
+		return m.CallToolFunc(ctx, toolName, args)
+	}
+	return &mcp_client.ToolResponse{}, nil
+}
+
+// Ensure mock implements the local interface (compile-time check)
+var _ mcpClient = (*mockMCPClient)(nil)
+
+var _ = Describe("MCPAgent", func() {
+	var (
+		ctx context.Context
+		// We test the public MCPAgent wrapper, which uses the implementations internally.
+		// The actual agent instance might be native or wasm depending on McpServerPath
+		agent      agents.Interface // Use the public agents.Interface
+		mockClient *mockMCPClient
+	)
+
+	BeforeEach(func() {
+		ctx = context.Background()
+		mockClient = &mockMCPClient{
+			callToolArgs: make([]any, 0), // Reset args on each test
+		}
+
+		// Instantiate the real agent using a testing constructor
+		// This constructor needs to be added to the mcp package.
+		agent = mcp.NewAgentForTesting(mockClient)
+		Expect(agent).NotTo(BeNil(), "Agent should be created")
+	})
+
+	// Helper to get the concrete agent type for calling specific methods
+	getConcreteAgent := func() *mcp.MCPAgent {
+		concreteAgent, ok := agent.(*mcp.MCPAgent)
+		Expect(ok).To(BeTrue(), "Agent should be of type *mcp.MCPAgent")
+		return concreteAgent
+	}
+
+	Describe("GetArtistBiography", func() {
+		It("should call the correct tool and return the biography", func() {
+			expectedBio := "This is the artist bio."
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				Expect(toolName).To(Equal(mcp.McpToolNameGetBio))
+				Expect(args).To(BeAssignableToTypeOf(mcp.ArtistArgs{}))
+				typedArgs := args.(mcp.ArtistArgs)
+				Expect(typedArgs.ID).To(Equal("id1"))
+				Expect(typedArgs.Name).To(Equal("Artist Name"))
+				Expect(typedArgs.Mbid).To(Equal("mbid1"))
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent(expectedBio)), nil
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(bio).To(Equal(expectedBio))
+		})
+
+		It("should return error if CallTool fails", func() {
+			expectedErr := errors.New("mcp tool error")
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return nil, expectedErr
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(HaveOccurred())
+			// The error originates from the implementation now, check for specific part
+			Expect(err.Error()).To(SatisfyAny(
+				ContainSubstring("native MCP agent not ready"), // Error from native
+				ContainSubstring("WASM MCP agent not ready"),   // Error from WASM
+				ContainSubstring("failed to call native MCP tool"),
+				ContainSubstring("failed to call WASM MCP tool"),
+			))
+			Expect(errors.Is(err, expectedErr)).To(BeTrue())
+			Expect(bio).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if CallTool response is empty", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				// Return a response created with no content parts
+				return mcp_client.NewToolResponse(), nil
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(bio).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if CallTool response has nil TextContent (simulated by empty string)", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				// Simulate nil/empty text content by creating response with empty string text
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent("")), nil
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(bio).To(BeEmpty())
+		})
+
+		It("should return comm error if CallTool returns pipe error", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return nil, io.ErrClosedPipe
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(SatisfyAny(
+				ContainSubstring("native MCP agent process communication error"),
+				ContainSubstring("WASM MCP agent module communication error"),
+			))
+			Expect(errors.Is(err, io.ErrClosedPipe)).To(BeTrue())
+			Expect(bio).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if MCP tool returns an error string", func() {
+			mcpErrorString := "handler returned an error: something went wrong on the server"
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent(mcpErrorString)), nil
+			}
+
+			bio, err := getConcreteAgent().GetArtistBiography(ctx, "id1", "Artist Name", "mbid1")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(bio).To(BeEmpty())
+		})
+	})
+
+	Describe("GetArtistURL", func() {
+		It("should call the correct tool and return the URL", func() {
+			expectedURL := "http://example.com/artist"
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				Expect(toolName).To(Equal(mcp.McpToolNameGetURL))
+				Expect(args).To(BeAssignableToTypeOf(mcp.ArtistArgs{}))
+				typedArgs := args.(mcp.ArtistArgs)
+				Expect(typedArgs.ID).To(Equal("id2"))
+				Expect(typedArgs.Name).To(Equal("Another Artist"))
+				Expect(typedArgs.Mbid).To(Equal("mbid2"))
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent(expectedURL)), nil
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(url).To(Equal(expectedURL))
+		})
+
+		It("should return error if CallTool fails", func() {
+			expectedErr := errors.New("mcp tool error url")
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return nil, expectedErr
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(SatisfyAny(
+				ContainSubstring("native MCP agent not ready"), // Error from native
+				ContainSubstring("WASM MCP agent not ready"),   // Error from WASM
+				ContainSubstring("failed to call native MCP tool"),
+				ContainSubstring("failed to call WASM MCP tool"),
+			))
+			Expect(errors.Is(err, expectedErr)).To(BeTrue())
+			Expect(url).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if CallTool response is empty", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				// Return a response created with no content parts
+				return mcp_client.NewToolResponse(), nil
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(url).To(BeEmpty())
+		})
+
+		It("should return comm error if CallTool returns pipe error", func() {
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return nil, fmt.Errorf("write: %w", io.ErrClosedPipe)
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(SatisfyAny(
+				ContainSubstring("native MCP agent process communication error"),
+				ContainSubstring("WASM MCP agent module communication error"),
+			))
+			Expect(errors.Is(err, io.ErrClosedPipe)).To(BeTrue())
+			Expect(url).To(BeEmpty())
+		})
+
+		It("should return ErrNotFound if MCP tool returns an error string", func() {
+			mcpErrorString := "handler returned an error: could not find url"
+			mockClient.CallToolFunc = func(ctx context.Context, toolName string, args any) (*mcp_client.ToolResponse, error) {
+				return mcp_client.NewToolResponse(mcp_client.NewTextContent(mcpErrorString)), nil
+			}
+
+			url, err := getConcreteAgent().GetArtistURL(ctx, "id2", "Another Artist", "mbid2")
+			Expect(err).To(MatchError(agents.ErrNotFound))
+			Expect(url).To(BeEmpty())
+		})
+	})
+})

core/agents/mcp/mcp_host_functions.go

@@ -0,0 +1,189 @@
+package mcp
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/tetratelabs/wazero"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// httpClient is a shared HTTP client for host function reuse.
+var httpClient = &http.Client{
+	// Consider adding a default timeout
+	Timeout: 30 * time.Second,
+}
+
+// registerHostFunctions defines and registers the host functions (e.g., http_fetch)
+// into the provided Wazero runtime.
+func registerHostFunctions(ctx context.Context, runtime wazero.Runtime) error {
+	// Define and Instantiate Host Module "env"
+	_, err := runtime.NewHostModuleBuilder("env"). // "env" is the conventional module name
+							NewFunctionBuilder().
+							WithFunc(httpFetch).  // Register our Go function
+							Export("http_fetch"). // Export it with the name WASM will use
+							Instantiate(ctx)
+	if err != nil {
+		log.Error(ctx, "Failed to instantiate 'env' host module with httpFetch", "error", err)
+		return fmt.Errorf("instantiate host module 'env': %w", err)
+	}
+	log.Info(ctx, "Instantiated 'env' host module with http_fetch function")
+	return nil
+}
+
+// httpFetch is the host function exposed to WASM.
+// ... (full implementation as provided previously) ...
+// Returns:
+// - 0 on success (request completed, results written).
+// - 1 on host-side failure (e.g., memory access error, invalid input).
+func httpFetch(
+	ctx context.Context, mod api.Module, // Standard Wazero host function params
+	// Request details
+	urlPtr, urlLen uint32,
+	methodPtr, methodLen uint32,
+	bodyPtr, bodyLen uint32,
+	timeoutMillis uint32,
+	// Result pointers
+	resultStatusPtr uint32,
+	resultBodyPtr uint32, resultBodyCapacity uint32, resultBodyLenPtr uint32,
+	resultErrorPtr uint32, resultErrorCapacity uint32, resultErrorLenPtr uint32,
+) uint32 { // Using uint32 for status code convention (0=success, 1=failure)
+	mem := mod.Memory()
+
+	// --- Read Inputs ---
+	urlBytes, ok := mem.Read(urlPtr, urlLen)
+	if !ok {
+		log.Error(ctx, "httpFetch host error: failed to read URL from WASM memory")
+		// Cannot write error back as we don't have the pointers validated yet
+		return 1
+	}
+	url := string(urlBytes)
+
+	methodBytes, ok := mem.Read(methodPtr, methodLen)
+	if !ok {
+		log.Error(ctx, "httpFetch host error: failed to read method from WASM memory", "url", url)
+		return 1 // Bail out
+	}
+	method := string(methodBytes)
+	if method == "" {
+		method = "GET" // Default to GET
+	}
+
+	var reqBody io.Reader
+	if bodyLen > 0 {
+		bodyBytes, ok := mem.Read(bodyPtr, bodyLen)
+		if !ok {
+			log.Error(ctx, "httpFetch host error: failed to read body from WASM memory", "url", url, "method", method)
+			return 1 // Bail out
+		}
+		reqBody = bytes.NewReader(bodyBytes)
+	}
+
+	timeout := time.Duration(timeoutMillis) * time.Millisecond
+	if timeout <= 0 {
+		timeout = 30 * time.Second // Default timeout matching httpClient
+	}
+
+	// --- Prepare and Execute Request ---
+	log.Debug(ctx, "httpFetch executing request", "method", method, "url", url, "timeout", timeout)
+
+	// Use a specific context for the request, derived from the host function's context
+	// but with the specific timeout for this call.
+	reqCtx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(reqCtx, method, url, reqBody)
+	if err != nil {
+		errMsg := fmt.Sprintf("failed to create request: %v", err)
+		log.Error(ctx, "httpFetch host error", "url", url, "method", method, "error", errMsg)
+		writeStringResult(mem, resultErrorPtr, resultErrorCapacity, resultErrorLenPtr, errMsg)
+		mem.WriteUint32Le(resultStatusPtr, 0)  // Write 0 status on creation error
+		mem.WriteUint32Le(resultBodyLenPtr, 0) // No body
+		return 0                               // Indicate results (including error) were written
+	}
+
+	// TODO: Consider adding a User-Agent?
+	// req.Header.Set("User-Agent", "Navidrome/MCP-Agent-Host")
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		// Handle client-side errors (network, DNS, timeout)
+		errMsg := fmt.Sprintf("failed to execute request: %v", err)
+		log.Error(ctx, "httpFetch host error", "url", url, "method", method, "error", errMsg)
+		writeStringResult(mem, resultErrorPtr, resultErrorCapacity, resultErrorLenPtr, errMsg)
+		mem.WriteUint32Le(resultStatusPtr, 0) // Write 0 status on transport error
+		mem.WriteUint32Le(resultBodyLenPtr, 0)
+		return 0 // Indicate results written
+	}
+	defer resp.Body.Close()
+
+	// --- Process Response ---
+	statusCode := uint32(resp.StatusCode)
+	responseBodyBytes, readErr := io.ReadAll(resp.Body)
+	if readErr != nil {
+		errMsg := fmt.Sprintf("failed to read response body: %v", readErr)
+		log.Error(ctx, "httpFetch host error", "url", url, "method", method, "status", statusCode, "error", errMsg)
+		writeStringResult(mem, resultErrorPtr, resultErrorCapacity, resultErrorLenPtr, errMsg)
+		mem.WriteUint32Le(resultStatusPtr, statusCode) // Write actual status code
+		mem.WriteUint32Le(resultBodyLenPtr, 0)
+		return 0 // Indicate results written
+	}
+
+	// --- Write Results Back to WASM Memory ---
+	log.Debug(ctx, "httpFetch writing results", "url", url, "method", method, "status", statusCode, "bodyLen", len(responseBodyBytes))
+
+	// Write status code
+	if !mem.WriteUint32Le(resultStatusPtr, statusCode) {
+		log.Error(ctx, "httpFetch host error: failed to write status code to WASM memory")
+		return 1 // Host error
+	}
+
+	// Write response body (checking capacity)
+	if !writeBytesResult(mem, resultBodyPtr, resultBodyCapacity, resultBodyLenPtr, responseBodyBytes) {
+		// If body write fails (likely due to capacity), write an error message instead.
+		errMsg := fmt.Sprintf("response body size (%d) exceeds buffer capacity (%d)", len(responseBodyBytes), resultBodyCapacity)
+		log.Error(ctx, "httpFetch host error", "url", url, "method", method, "status", statusCode, "error", errMsg)
+		writeStringResult(mem, resultErrorPtr, resultErrorCapacity, resultErrorLenPtr, errMsg)
+		mem.WriteUint32Le(resultBodyLenPtr, 0) // Ensure body length is 0 if we wrote an error
+	} else {
+		// Write empty error string if body write was successful
+		mem.WriteUint32Le(resultErrorLenPtr, 0)
+	}
+
+	return 0 // Success
+}
+
+// Helper to write string results, respecting capacity. Returns true on success.
+func writeStringResult(mem api.Memory, ptr, capacity, lenPtr uint32, result string) bool {
+	bytes := []byte(result)
+	return writeBytesResult(mem, ptr, capacity, lenPtr, bytes)
+}
+
+// Helper to write byte results, respecting capacity. Returns true on success.
+func writeBytesResult(mem api.Memory, ptr, capacity, lenPtr uint32, result []byte) bool {
+	resultLen := uint32(len(result))
+	writeLen := resultLen
+	if writeLen > capacity {
+		log.Warn(context.Background(), "WASM host write truncated", "requested", resultLen, "capacity", capacity)
+		writeLen = capacity // Truncate if too large for buffer
+	}
+
+	if writeLen > 0 {
+		if !mem.Write(ptr, result[:writeLen]) {
+			log.Error(context.Background(), "WASM host memory write failed", "ptr", ptr, "len", writeLen)
+			return false // Memory write failed
+		}
+	}
+
+	// Write the *original* length of the data (even if truncated) so the WASM side knows.
+	if !mem.WriteUint32Le(lenPtr, resultLen) {
+		log.Error(context.Background(), "WASM host memory length write failed", "lenPtr", lenPtr, "len", resultLen)
+		return false // Memory write failed
+	}
+	return true
+}

core/agents/mcp/mcp_process_native.go

@@ -0,0 +1,252 @@
+package mcp
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+
+	mcp "github.com/metoro-io/mcp-golang"
+	"github.com/metoro-io/mcp-golang/transport/stdio"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/log"
+)
+
+// MCPNative implements the mcpImplementation interface for running the MCP server as a native process.
+type MCPNative struct {
+	mu     sync.Mutex
+	cmd    *exec.Cmd // Stores the running command
+	stdin  io.WriteCloser
+	client mcpClient
+
+	// ClientOverride allows injecting a mock client for testing this specific implementation.
+	ClientOverride mcpClient // TODO: Consider if this is the best way to test
+}
+
+// newMCPNative creates a new instance of the native MCP agent implementation.
+func newMCPNative() *MCPNative {
+	return &MCPNative{}
+}
+
+// --- mcpImplementation interface methods ---
+
+func (n *MCPNative) Close() error {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	n.cleanupResources_locked()
+	return nil // Currently, cleanup doesn't return errors
+}
+
+// --- Internal Helper Methods ---
+
+// ensureClientInitialized starts the MCP server process and initializes the client if needed.
+// MUST be called with the mutex HELD.
+func (n *MCPNative) ensureClientInitialized_locked(ctx context.Context) error {
+	// Use override if provided (for testing)
+	if n.ClientOverride != nil {
+		if n.client == nil {
+			n.client = n.ClientOverride
+			log.Debug(ctx, "Using provided MCP client override for native testing")
+		}
+		return nil
+	}
+
+	// Check if already initialized
+	if n.client != nil {
+		return nil
+	}
+
+	log.Info(ctx, "Initializing Native MCP client and starting/restarting server process...", "serverPath", McpServerPath)
+
+	// Clean up any old resources *before* starting new ones
+	n.cleanupResources_locked()
+
+	hostStdinWriter, hostStdoutReader, nativeCmd, startErr := n.startProcess_locked(ctx)
+	if startErr != nil {
+		log.Error(ctx, "Failed to start Native MCP server process", "error", startErr)
+		// Ensure pipes are closed if start failed (startProcess might handle this, but be sure)
+		if hostStdinWriter != nil {
+			_ = hostStdinWriter.Close()
+		}
+		if hostStdoutReader != nil {
+			_ = hostStdoutReader.Close()
+		}
+		return fmt.Errorf("failed to start native MCP server: %w", startErr)
+	}
+
+	// --- Initialize MCP client ---
+	transport := stdio.NewStdioServerTransportWithIO(hostStdoutReader, hostStdinWriter)
+	clientImpl := mcp.NewClient(transport)
+
+	initCtx, cancel := context.WithTimeout(context.Background(), initializationTimeout)
+	defer cancel()
+	if _, initErr := clientImpl.Initialize(initCtx); initErr != nil {
+		err := fmt.Errorf("failed to initialize native MCP client: %w", initErr)
+		log.Error(ctx, "Native MCP client initialization failed", "error", err)
+		// Cleanup the newly started process and close pipes
+		n.cmd = nativeCmd // Temporarily set cmd so cleanup can kill it
+		n.cleanupResources_locked()
+		if hostStdinWriter != nil {
+			_ = hostStdinWriter.Close()
+		}
+		if hostStdoutReader != nil {
+			_ = hostStdoutReader.Close()
+		}
+		return err
+	}
+
+	// --- Initialization successful, update agent state ---
+	n.cmd = nativeCmd
+	n.stdin = hostStdinWriter // This is the pipe the agent writes to
+	n.client = clientImpl
+
+	log.Info(ctx, "Native MCP client initialized successfully", "pid", n.cmd.Process.Pid)
+	return nil // Success
+}
+
+// callMCPTool handles ensuring initialization and calling the MCP tool.
+func (n *MCPNative) callMCPTool(ctx context.Context, toolName string, args any) (string, error) {
+	// Ensure the client is initialized and the server is running (attempts restart if needed)
+	n.mu.Lock()
+	err := n.ensureClientInitialized_locked(ctx)
+	if err != nil {
+		n.mu.Unlock()
+		log.Error(ctx, "Native MCP agent initialization/restart failed", "tool", toolName, "error", err)
+		return "", fmt.Errorf("native MCP agent not ready: %w", err)
+	}
+
+	// Keep a reference to the client while locked
+	currentClient := n.client
+	// Unlock mutex *before* making the potentially blocking MCP call
+	n.mu.Unlock()
+
+	// Call the tool using the client reference
+	log.Debug(ctx, "Calling Native MCP tool", "tool", toolName, "args", args)
+	response, callErr := currentClient.CallTool(ctx, toolName, args)
+	if callErr != nil {
+		// Handle potential pipe closures or other communication errors
+		log.Error(ctx, "Failed to call Native MCP tool", "tool", toolName, "error", callErr)
+		// Check if the error indicates a broken pipe, suggesting the server died
+		// The monitoring goroutine will handle cleanup, just return error here.
+		if errors.Is(callErr, io.ErrClosedPipe) || strings.Contains(callErr.Error(), "broken pipe") || strings.Contains(callErr.Error(), "EOF") {
+			log.Warn(ctx, "Native MCP tool call failed, possibly due to server process exit.", "tool", toolName)
+			// No need to explicitly call cleanup, monitoring goroutine handles it.
+			return "", fmt.Errorf("native MCP agent process communication error: %w", callErr)
+		}
+		return "", fmt.Errorf("failed to call native MCP tool '%s': %w", toolName, callErr)
+	}
+
+	// Process the response (same logic as before)
+	if response == nil || len(response.Content) == 0 || response.Content[0].TextContent == nil || response.Content[0].TextContent.Text == "" {
+		log.Warn(ctx, "Native MCP tool returned empty/invalid response", "tool", toolName)
+		// Treat as not found for agent interface consistency
+		return "", agents.ErrNotFound // Import agents package if needed, or define locally
+	}
+	resultText := response.Content[0].TextContent.Text
+	if strings.HasPrefix(resultText, "handler returned an error:") {
+		log.Warn(ctx, "Native MCP tool returned an error message", "tool", toolName, "mcpError", resultText)
+		return "", agents.ErrNotFound // Treat MCP tool errors as "not found"
+	}
+
+	log.Debug(ctx, "Received response from Native MCP agent", "tool", toolName, "length", len(resultText))
+	return resultText, nil
+}
+
+// cleanupResources closes existing resources (stdin, server process).
+// MUST be called with the mutex HELD.
+func (n *MCPNative) cleanupResources_locked() {
+	log.Debug(context.Background(), "Cleaning up Native MCP instance resources...")
+	if n.stdin != nil {
+		_ = n.stdin.Close()
+		n.stdin = nil
+	}
+	if n.cmd != nil && n.cmd.Process != nil {
+		pid := n.cmd.Process.Pid
+		log.Debug(context.Background(), "Killing native MCP process", "pid", pid)
+		// Kill the process. Ignore error if it's already done.
+		if err := n.cmd.Process.Kill(); err != nil && !errors.Is(err, os.ErrProcessDone) {
+			log.Error(context.Background(), "Failed to kill native process", "pid", pid, "error", err)
+		}
+		// Wait for the process to release resources. Ignore error.
+		_ = n.cmd.Wait()
+		n.cmd = nil
+	}
+	// Mark client as invalid
+	n.client = nil
+}
+
+// startProcess starts the MCP server as a native executable and sets up monitoring.
+// MUST be called with the mutex HELD.
+func (n *MCPNative) startProcess_locked(ctx context.Context) (stdin io.WriteCloser, stdout io.ReadCloser, cmd *exec.Cmd, err error) {
+	log.Debug(ctx, "Starting native MCP server process", "path", McpServerPath)
+	// Use Background context for the command itself, as it should outlive the request context (ctx)
+	cmd = exec.CommandContext(context.Background(), McpServerPath)
+
+	stdinPipe, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("native stdin pipe: %w", err)
+	}
+
+	stdoutPipe, err := cmd.StdoutPipe()
+	if err != nil {
+		_ = stdinPipe.Close()
+		return nil, nil, nil, fmt.Errorf("native stdout pipe: %w", err)
+	}
+
+	// Get stderr pipe to stream logs
+	stderrPipe, err := cmd.StderrPipe()
+	if err != nil {
+		_ = stdinPipe.Close()
+		_ = stdoutPipe.Close()
+		return nil, nil, nil, fmt.Errorf("native stderr pipe: %w", err)
+	}
+
+	if err = cmd.Start(); err != nil {
+		_ = stdinPipe.Close()
+		_ = stdoutPipe.Close()
+		// stderrPipe gets closed implicitly if cmd.Start() fails
+		return nil, nil, nil, fmt.Errorf("native start: %w", err)
+	}
+
+	currentPid := cmd.Process.Pid
+	currentCmd := cmd // Capture the current cmd pointer for the goroutine
+	log.Info(ctx, "Native MCP server process started", "pid", currentPid)
+
+	// Start monitoring goroutine for process exit
+	go func() {
+		// Start separate goroutine to stream stderr
+		go func() {
+			scanner := bufio.NewScanner(stderrPipe)
+			for scanner.Scan() {
+				log.Info("[MCP-SERVER] " + scanner.Text())
+			}
+			if err := scanner.Err(); err != nil {
+				log.Error("Error reading MCP server stderr", "pid", currentPid, "error", err)
+			}
+			log.Debug("MCP server stderr pipe closed", "pid", currentPid)
+		}()
+
+		waitErr := currentCmd.Wait() // Wait for the specific process this goroutine monitors
+		n.mu.Lock()
+		// Stderr is now streamed, so we don't capture it here anymore.
+		log.Warn("Native MCP server process exited", "pid", currentPid, "error", waitErr)
+
+		// Critical: Check if the agent's current command is STILL the one we were monitoring.
+		// If it's different, it means cleanup/restart already happened, so we shouldn't cleanup again.
+		if n.cmd == currentCmd {
+			n.cleanupResources_locked() // Use the locked version as we hold the lock
+			log.Info("MCP Native agent state cleaned up after process exit", "pid", currentPid)
+		} else {
+			log.Debug("Native MCP process exited, but state already updated/cmd mismatch", "exitedPid", currentPid)
+		}
+		n.mu.Unlock()
+	}()
+
+	// Return the pipes connected to the process and the Cmd object
+	return stdinPipe, stdoutPipe, cmd, nil
+}

core/agents/mcp/mcp_process_wazero.go

@@ -0,0 +1,305 @@
+package mcp
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	mcp "github.com/metoro-io/mcp-golang"
+	"github.com/metoro-io/mcp-golang/transport/stdio"
+	"github.com/navidrome/navidrome/core/agents" // Needed for ErrNotFound
+	"github.com/navidrome/navidrome/log"
+	"github.com/tetratelabs/wazero"     // Needed for types
+	"github.com/tetratelabs/wazero/api" // Needed for types
+)
+
+// MCPWasm implements the mcpImplementation interface for running the MCP server as a WASM module.
+type MCPWasm struct {
+	mu           sync.Mutex
+	wasmModule   api.Module // Stores the instantiated module
+	wasmCompiled api.Closer // Stores the compiled module reference for this instance
+	stdin        io.WriteCloser
+	client       mcpClient
+
+	// Shared resources (passed in, not owned by this struct)
+	wasmRuntime       api.Closer              // Shared Wazero Runtime
+	wasmCache         wazero.CompilationCache // Shared Compilation Cache (can be nil)
+	preCompiledModule wazero.CompiledModule   // Pre-compiled module from constructor
+
+	// ClientOverride allows injecting a mock client for testing this specific implementation.
+	ClientOverride mcpClient // TODO: Consider if this is the best way to test
+}
+
+// newMCPWasm creates a new instance of the WASM MCP agent implementation.
+// It stores the shared runtime, cache, and the pre-compiled module.
+func newMCPWasm(runtime api.Closer, cache wazero.CompilationCache, compiledModule wazero.CompiledModule) *MCPWasm {
+	return &MCPWasm{
+		wasmRuntime:       runtime,
+		wasmCache:         cache,
+		preCompiledModule: compiledModule,
+	}
+}
+
+// --- mcpImplementation interface methods ---
+
+// Close cleans up instance-specific WASM resources.
+// It does NOT close the shared runtime or cache.
+func (w *MCPWasm) Close() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.cleanupResources_locked()
+	return nil
+}
+
+// --- Internal Helper Methods ---
+
+// ensureClientInitialized starts the MCP WASM module and initializes the client if needed.
+// MUST be called with the mutex HELD.
+func (w *MCPWasm) ensureClientInitialized_locked(ctx context.Context) error {
+	// Use override if provided (for testing)
+	if w.ClientOverride != nil {
+		if w.client == nil {
+			w.client = w.ClientOverride
+			log.Debug(ctx, "Using provided MCP client override for WASM testing")
+		}
+		return nil
+	}
+
+	// Check if already initialized
+	if w.client != nil {
+		return nil
+	}
+
+	log.Info(ctx, "Initializing WASM MCP client and starting/restarting server module...", "serverPath", McpServerPath)
+
+	w.cleanupResources_locked()
+
+	// Check if shared runtime exists
+	if w.wasmRuntime == nil {
+		return errors.New("shared Wazero runtime not initialized for MCPWasm")
+	}
+
+	hostStdinWriter, hostStdoutReader, mod, err := w.startModule_locked(ctx)
+	if err != nil {
+		log.Error(ctx, "Failed to start WASM MCP server module", "error", err)
+		// Ensure pipes are closed if start failed
+		if hostStdinWriter != nil {
+			_ = hostStdinWriter.Close()
+		}
+		if hostStdoutReader != nil {
+			_ = hostStdoutReader.Close()
+		}
+		// startModule_locked handles cleanup of mod/compiled on error
+		return fmt.Errorf("failed to start WASM MCP server: %w", err)
+	}
+
+	transport := stdio.NewStdioServerTransportWithIO(hostStdoutReader, hostStdinWriter)
+	clientImpl := mcp.NewClient(transport)
+
+	initCtx, cancel := context.WithTimeout(context.Background(), initializationTimeout)
+	defer cancel()
+	if _, initErr := clientImpl.Initialize(initCtx); initErr != nil {
+		err := fmt.Errorf("failed to initialize WASM MCP client: %w", initErr)
+		log.Error(ctx, "WASM MCP client initialization failed", "error", err)
+		// Cleanup the newly started module and close pipes
+		w.wasmModule = mod   // Temporarily set so cleanup can close it
+		w.wasmCompiled = nil // We don't store the compiled instance ref anymore, just the module instance
+		w.cleanupResources_locked()
+		if hostStdinWriter != nil {
+			_ = hostStdinWriter.Close()
+		}
+		if hostStdoutReader != nil {
+			_ = hostStdoutReader.Close()
+		}
+		return err
+	}
+
+	w.wasmModule = mod
+	w.wasmCompiled = nil // We don't store the compiled instance ref anymore, just the module instance
+	w.stdin = hostStdinWriter
+	w.client = clientImpl
+
+	log.Info(ctx, "WASM MCP client initialized successfully")
+	return nil
+}
+
+// callMCPTool handles ensuring initialization and calling the MCP tool.
+func (w *MCPWasm) callMCPTool(ctx context.Context, toolName string, args any) (string, error) {
+	w.mu.Lock()
+	err := w.ensureClientInitialized_locked(ctx)
+	if err != nil {
+		w.mu.Unlock()
+		log.Error(ctx, "WASM MCP agent initialization/restart failed", "tool", toolName, "error", err)
+		return "", fmt.Errorf("WASM MCP agent not ready: %w", err)
+	}
+
+	// Keep a reference to the client while locked
+	currentClient := w.client
+	// Unlock mutex *before* making the potentially blocking MCP call
+	w.mu.Unlock()
+
+	// Call the tool using the client reference
+	log.Debug(ctx, "Calling WASM MCP tool", "tool", toolName, "args", args)
+	response, callErr := currentClient.CallTool(ctx, toolName, args)
+	if callErr != nil {
+		// Handle potential pipe closures or other communication errors
+		log.Error(ctx, "Failed to call WASM MCP tool", "tool", toolName, "error", callErr)
+		// Check if the error indicates a broken pipe, suggesting the server died
+		// The monitoring goroutine will handle cleanup, just return error here.
+		if errors.Is(callErr, io.ErrClosedPipe) || strings.Contains(callErr.Error(), "broken pipe") || strings.Contains(callErr.Error(), "EOF") {
+			log.Warn(ctx, "WASM MCP tool call failed, possibly due to server module exit.", "tool", toolName)
+			// No need to explicitly call cleanup, monitoring goroutine handles it.
+			return "", fmt.Errorf("WASM MCP agent module communication error: %w", callErr)
+		}
+		return "", fmt.Errorf("failed to call WASM MCP tool '%s': %w", toolName, callErr)
+	}
+
+	// Process the response (same logic as native)
+	if response == nil || len(response.Content) == 0 || response.Content[0].TextContent == nil || response.Content[0].TextContent.Text == "" {
+		log.Warn(ctx, "WASM MCP tool returned empty/invalid response", "tool", toolName)
+		return "", agents.ErrNotFound
+	}
+	resultText := response.Content[0].TextContent.Text
+	if strings.HasPrefix(resultText, "handler returned an error:") {
+		log.Warn(ctx, "WASM MCP tool returned an error message", "tool", toolName, "mcpError", resultText)
+		return "", agents.ErrNotFound // Treat MCP tool errors as "not found"
+	}
+
+	log.Debug(ctx, "Received response from WASM MCP agent", "tool", toolName, "length", len(resultText))
+	return resultText, nil
+}
+
+// cleanupResources closes instance-specific WASM resources (stdin, module, compiled ref).
+// It specifically avoids closing the shared runtime or cache.
+// MUST be called with the mutex HELD.
+func (w *MCPWasm) cleanupResources_locked() {
+	log.Debug(context.Background(), "Cleaning up WASM MCP instance resources...")
+	if w.stdin != nil {
+		_ = w.stdin.Close()
+		w.stdin = nil
+	}
+	// Close the module instance
+	if w.wasmModule != nil {
+		log.Debug(context.Background(), "Closing WASM module instance")
+		ctxClose, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+		if err := w.wasmModule.Close(ctxClose); err != nil && !errors.Is(err, context.DeadlineExceeded) {
+			log.Error(context.Background(), "Failed to close WASM module instance", "error", err)
+		}
+		cancel()
+		w.wasmModule = nil
+	}
+	// DO NOT close w.wasmCompiled (instance ref)
+	// DO NOT close w.preCompiledModule (shared pre-compiled code)
+	// DO NOT CLOSE w.wasmRuntime or w.wasmCache here!
+	w.client = nil
+}
+
+// startModule loads and starts the MCP server as a WASM module.
+// It now uses the pre-compiled module.
+// MUST be called with the mutex HELD.
+func (w *MCPWasm) startModule_locked(ctx context.Context) (hostStdinWriter io.WriteCloser, hostStdoutReader io.ReadCloser, mod api.Module, err error) {
+	// Check for pre-compiled module
+	if w.preCompiledModule == nil {
+		return nil, nil, nil, errors.New("pre-compiled WASM module is nil")
+	}
+
+	// Create pipes for stdio redirection
+	wasmStdinReader, hostStdinWriter, err := os.Pipe()
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("wasm stdin pipe: %w", err)
+	}
+	// Defer close pipes on error exit
+	shouldClosePipesOnError := true
+	defer func() {
+		if shouldClosePipesOnError {
+			if wasmStdinReader != nil {
+				_ = wasmStdinReader.Close()
+			}
+			if hostStdinWriter != nil {
+				_ = hostStdinWriter.Close()
+			}
+			// hostStdoutReader and wasmStdoutWriter handled below
+		}
+	}()
+
+	hostStdoutReader, wasmStdoutWriter, err := os.Pipe()
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("wasm stdout pipe: %w", err)
+	}
+	// Defer close pipes on error exit
+	defer func() {
+		if shouldClosePipesOnError {
+			if hostStdoutReader != nil {
+				_ = hostStdoutReader.Close()
+			}
+			if wasmStdoutWriter != nil {
+				_ = wasmStdoutWriter.Close()
+			}
+		}
+	}()
+
+	// Use the SHARDED runtime from the agent struct
+	runtime, ok := w.wasmRuntime.(wazero.Runtime)
+	if !ok || runtime == nil {
+		return nil, nil, nil, errors.New("wasmRuntime is not initialized or not a wazero.Runtime")
+	}
+
+	// Prepare module configuration (host funcs/WASI already instantiated on runtime)
+	config := wazero.NewModuleConfig().
+		WithStdin(wasmStdinReader).
+		WithStdout(wasmStdoutWriter).
+		WithStderr(os.Stderr).
+		WithArgs(McpServerPath).
+		WithFS(os.DirFS("/")) // Keep FS access for now
+
+	log.Info(ctx, "Instantiating pre-compiled WASM module (will run _start)...")
+	var moduleInstance api.Module
+	instanceErrChan := make(chan error, 1)
+	go func() {
+		var instantiateErr error
+		// Use context.Background() for the module's main execution context
+		moduleInstance, instantiateErr = runtime.InstantiateModule(context.Background(), w.preCompiledModule, config)
+		instanceErrChan <- instantiateErr
+	}()
+
+	// Wait briefly for immediate instantiation errors
+	select {
+	case instantiateErr := <-instanceErrChan:
+		if instantiateErr != nil {
+			log.Error(ctx, "Failed to instantiate pre-compiled WASM module", "error", instantiateErr)
+			// Pipes closed by defer
+			return nil, nil, nil, fmt.Errorf("instantiate wasm module: %w", instantiateErr)
+		}
+		log.Warn(ctx, "WASM module instantiation returned (exited?) immediately without error.")
+	case <-time.After(1 * time.Second): // Shorter wait now, instantiation should be faster
+		log.Debug(ctx, "WASM module instantiation likely blocking (server running), proceeding...")
+	}
+
+	// Start a monitoring goroutine for WASM module exit/error
+	go func(instanceToMonitor api.Module, errChan chan error) {
+		// This blocks until the instance created by InstantiateModule exits or errors.
+		instantiateErr := <-errChan
+
+		w.mu.Lock() // Lock the specific MCPWasm instance
+		log.Warn("WASM module exited/errored", "error", instantiateErr)
+
+		// Critical: Check if the agent's current module is STILL the one we were monitoring.
+		if w.wasmModule == instanceToMonitor {
+			w.cleanupResources_locked() // Use the locked version
+			log.Info("MCP WASM agent state cleaned up after module exit/error")
+		} else {
+			log.Debug("WASM module exited, but state already updated/module mismatch. No cleanup needed by this goroutine.")
+			// No need to close anything here, the pre-compiled module is shared
+		}
+		w.mu.Unlock()
+	}(moduleInstance, instanceErrChan)
+
+	// Success: prevent deferred cleanup of pipes
+	shouldClosePipesOnError = false
+	return hostStdinWriter, hostStdoutReader, moduleInstance, nil
+}

core/agents/mcp/mcp_suite_test.go

@@ -0,0 +1,17 @@
+package mcp_test
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestMCPAgent(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelFatal)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "MCP Agent Test Suite")
+}

core/external/provider.go

@@ -13,6 +13,7 @@ import (
 	"github.com/navidrome/navidrome/core/agents"
 	_ "github.com/navidrome/navidrome/core/agents/lastfm"
 	_ "github.com/navidrome/navidrome/core/agents/listenbrainz"
+	_ "github.com/navidrome/navidrome/core/agents/mcp"
 	_ "github.com/navidrome/navidrome/core/agents/spotify"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"

go.mod

@@ -38,6 +38,7 @@ require (
 	github.com/lestrrat-go/jwx/v2 v2.1.4
 	github.com/matoous/go-nanoid/v2 v2.1.0
 	github.com/mattn/go-sqlite3 v1.14.27
+	github.com/metoro-io/mcp-golang v0.11.0
 	github.com/microcosm-cc/bluemonday v1.0.27
 	github.com/mileusna/useragent v1.3.5
 	github.com/onsi/ginkgo/v2 v2.23.4
@@ -53,6 +54,7 @@ require (
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/viper v1.20.1
 	github.com/stretchr/testify v1.10.0
+	github.com/tetratelabs/wazero v1.9.0
 	github.com/unrolled/secure v1.17.0
 	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1
 	go.uber.org/goleak v1.3.0
@@ -68,7 +70,9 @@ require (
 
 require (
 	github.com/aymerick/douceur v0.2.0 // indirect
+	github.com/bahlo/generic-list-go v0.2.0 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/buger/jsonparser v1.1.1 // indirect
 	github.com/cespare/reflex v0.3.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/creack/pty v1.1.11 // indirect
@@ -85,6 +89,7 @@ require (
 	github.com/gorilla/css v1.0.1 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/invopop/jsonschema v0.12.0 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
@@ -96,9 +101,11 @@ require (
 	github.com/lestrrat-go/httprc v1.0.6 // indirect
 	github.com/lestrrat-go/iter v1.0.2 // indirect
 	github.com/lestrrat-go/option v1.0.1 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/mfridman/interpolate v0.0.2 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/ogier/pflag v0.0.1 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/prometheus/client_model v0.6.1 // indirect
 	github.com/prometheus/common v0.62.0 // indirect
@@ -113,6 +120,11 @@ require (
 	github.com/spf13/pflag v1.0.6 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/tidwall/gjson v1.18.0 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
+	github.com/tidwall/sjson v1.2.5 // indirect
+	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
 	github.com/zeebo/xxh3 v1.0.2 // indirect
 	go.uber.org/automaxprocs v1.6.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect

go.sum

@@ -8,12 +8,16 @@ github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kk
 github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA=
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
+github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
+github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bmatcuk/doublestar/v4 v4.8.1 h1:54Bopc5c2cAvhLRAzqOGCYHYyhcDHsFF4wWIR5wKP38=
 github.com/bmatcuk/doublestar/v4 v4.8.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 github.com/bradleyjkemp/cupaloy/v2 v2.8.0 h1:any4BmKE+jGIaMpnU8YgH/I2LPiLBufr6oMMlVBbn9M=
 github.com/bradleyjkemp/cupaloy/v2 v2.8.0/go.mod h1:bm7JXdkRd4BHJk9HpwqAI8BoAY1lps46Enkdqw6aRX0=
+github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
+github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
 github.com/cespare/reflex v0.3.1 h1:N4Y/UmRrjwOkNT0oQQnYsdr6YBxvHqtSfPB4mqOyAKk=
 github.com/cespare/reflex v0.3.1/go.mod h1:I+0Pnu2W693i7Hv6ZZG76qHTY0mgUa7uCIfCtikXojE=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
@@ -104,8 +108,11 @@ github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+l
 github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/invopop/jsonschema v0.12.0 h1:6ovsNSuvn9wEQVOyc72aycBMVQFKz7cPdMJn10CvzRI=
+github.com/invopop/jsonschema v0.12.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0=
 github.com/jellydator/ttlcache/v3 v3.3.0 h1:BdoC9cE81qXfrxeb9eoJi9dWrdhSuwXMAnHTbnBm4Wc=
 github.com/jellydator/ttlcache/v3 v3.3.0/go.mod h1:bj2/e0l4jRnQdrnSTaGTsh4GSXvMjQcy41i7th0GVGw=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kardianos/service v1.2.2 h1:ZvePhAHfvo0A7Mftk/tEzqEZ7Q4lgnR8sGz4xu1YX60=
@@ -142,12 +149,16 @@ github.com/lestrrat-go/jwx/v2 v2.1.4 h1:uBCMmJX8oRZStmKuMMOFb0Yh9xmEMgNJLgjuKKt4
 github.com/lestrrat-go/jwx/v2 v2.1.4/go.mod h1:nWRbDFR1ALG2Z6GJbBXzfQaYyvn751KuuyySN2yR6is=
 github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU=
 github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/matoous/go-nanoid/v2 v2.1.0 h1:P64+dmq21hhWdtvZfEAofnvJULaRR1Yib0+PnU669bE=
 github.com/matoous/go-nanoid/v2 v2.1.0/go.mod h1:KlbGNQ+FhrUNIHUxZdL63t7tl4LaPkZNpUULS8H4uVM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-sqlite3 v1.14.27 h1:drZCnuvf37yPfs95E5jd9s3XhdVWLal+6BOK6qrv6IU=
 github.com/mattn/go-sqlite3 v1.14.27/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/metoro-io/mcp-golang v0.11.0 h1:1k+VSE9QaeMTLn0gJ3FgE/DcjsCBsLFnz5eSFbgXUiI=
+github.com/metoro-io/mcp-golang v0.11.0/go.mod h1:ifLP9ZzKpN1UqFWNTpAHOqSvNkMK6b7d1FSZ5Lu0lN0=
 github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY=
 github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg=
 github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
@@ -167,6 +178,8 @@ github.com/onsi/gomega v1.37.0/go.mod h1:8D9+Txp43QWKhM24yyOBEdpkzN8FvJyAwecBgsU
 github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
 github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -234,8 +247,22 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
+github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
+github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
+github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
+github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
+github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
 github.com/unrolled/secure v1.17.0 h1:Io7ifFgo99Bnh0J7+Q+qcMzWM6kaDPCA5FroFZEdbWU=
 github.com/unrolled/secure v1.17.0/go.mod h1:BmF5hyM6tXczk3MpQkFf1hpKSRqCyhqcbiQtiAF7+40=
+github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc=
+github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw=
 github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
 github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=

mcp-server/README.md

@@ -0,0 +1 @@
+