feat(issue): add get_discussion_markdown to issue_read

Adds a new issue_read method that fetches an issue and its comments
and renders them as a single Markdown document, instead of a JSON
array. Formatting logic lives in a pure, unit-tested helper
(formatDiscussionMarkdown) covering comment rendering, empty comment
lists, and attachment-inlined bodies. Existing get/get_comments/
get_labels methods are unchanged.

Co-Authored-By: Codet <codet@commitgo.dev> (GPT-5-Codex)

README.md

@@ -20,14 +20,6 @@ make install
 
 Pass the Gitea host and access token as command-line flags or environment variables, flags take precedence. Run `gitea-mcp --help` for the full list of flags and environment variables. Logs are written to `$HOME/.gitea-mcp/gitea-mcp.log`, add `-d` for debug logging.
 
-Set `GITEA_EXTRA_HEADERS` to a JSON object of header name/value pairs to send with every outbound request to Gitea, for example when Gitea sits behind Cloudflare Access:
-
-```bash
-export GITEA_EXTRA_HEADERS='{"CF-Access-Client-Id":"id","CF-Access-Client-Secret":"secret"}'
-```
-
-These headers never override `Authorization`, `Content-Type`, or `Accept` set by `gitea-mcp` itself.
-
 ### MCP protocol and HTTP transport
 
 The server supports MCP up to `2026-07-28` and negotiates down to the client's version, advertising only the `tools` capability. Tool and Gitea failures return a `tools/call` result with `result.isError: true`, while malformed requests and server faults stay JSON-RPC errors.

cmd/cmd.go

@@ -2,11 +2,9 @@ package cmd
 
 import (
 	"context"
-	"encoding/json"
 	"flag"
 	"fmt"
 	"io"
-	"net/http"
 	"os"
 	"strconv"
 	"strings"
@@ -88,7 +86,6 @@ func initFlagSet(fs *flag.FlagSet, args []string, getenv func(string) string, re
 		fmt.Fprintf(w, "  GITEA_ACCESS_TOKEN\tProvide access token\n")
 		fmt.Fprintf(w, "  GITEA_ACCESS_TOKEN_FILE\tPath to a file containing the access token (e.g. a Docker secret)\n")
 		fmt.Fprintf(w, "  GITEA_DEBUG\tSet to 'true' for debug mode\n")
-		fmt.Fprintf(w, "  GITEA_EXTRA_HEADERS\tJSON object of extra HTTP headers to send with Gitea API requests\n")
 		fmt.Fprintf(w, "  GITEA_HOST\tOverride Gitea host URL\n")
 		fmt.Fprintf(w, "  GITEA_INSECURE\tSet to 'true' to ignore TLS errors\n")
 		fmt.Fprintf(w, "  GITEA_MAX_INLINE_ATTACHMENT_BYTES\tOverride inline image attachment size limit in bytes\n")
@@ -167,18 +164,6 @@ func initFlagSet(fs *flag.FlagSet, args []string, getenv func(string) string, re
 			flagPkg.MaxInlineAttachmentBytes = parsed
 		}
 	}
-	if val := getenv("GITEA_EXTRA_HEADERS"); val != "" {
-		var headers map[string]string
-		if err := json.Unmarshal([]byte(val), &headers); err != nil {
-			fmt.Fprintf(stderr, "invalid GITEA_EXTRA_HEADERS: %v\n", err)
-			osExit(1)
-		}
-		extraHeaders := make(http.Header, len(headers))
-		for name, value := range headers {
-			extraHeaders.Set(name, value)
-		}
-		flagPkg.ExtraHeaders = extraHeaders
-	}
 }
 
 // normalizeScope trims whitespace, lowercases, and converts internal spaces

cmd/cmd_test.go

@@ -5,7 +5,6 @@ import (
 	"flag"
 	"maps"
 	"slices"
-	"strings"
 	"testing"
 
 	flagPkg "gitea.com/gitea/gitea-mcp/pkg/flag"
@@ -96,54 +95,3 @@ func TestInitFlagSetScopes(t *testing.T) {
 		})
 	}
 }
-
-func TestInitFlagSetExtraHeaders(t *testing.T) {
-	t.Cleanup(func() { flagPkg.ExtraHeaders = nil })
-
-	getenv := func(key string) string {
-		if key == "GITEA_EXTRA_HEADERS" {
-			return `{"CF-Access-Client-Id":"id","CF-Access-Client-Secret":"secret"}`
-		}
-		return ""
-	}
-	readFile := func(string) ([]byte, error) { return nil, nil }
-	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	var stderr bytes.Buffer
-
-	initFlagSet(fs, []string{}, getenv, readFile, &stderr)
-
-	if got := flagPkg.ExtraHeaders.Get("CF-Access-Client-Id"); got != "id" {
-		t.Errorf("ExtraHeaders[CF-Access-Client-Id] = %q, want %q", got, "id")
-	}
-	if got := flagPkg.ExtraHeaders.Get("CF-Access-Client-Secret"); got != "secret" {
-		t.Errorf("ExtraHeaders[CF-Access-Client-Secret] = %q, want %q", got, "secret")
-	}
-}
-
-func TestInitFlagSetExtraHeadersInvalidJSON(t *testing.T) {
-	t.Cleanup(func() { flagPkg.ExtraHeaders = nil })
-
-	origOsExit := osExit
-	var exitCode int
-	osExit = func(code int) { exitCode = code }
-	t.Cleanup(func() { osExit = origOsExit })
-
-	getenv := func(key string) string {
-		if key == "GITEA_EXTRA_HEADERS" {
-			return `not-json`
-		}
-		return ""
-	}
-	readFile := func(string) ([]byte, error) { return nil, nil }
-	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	var stderr bytes.Buffer
-
-	initFlagSet(fs, []string{}, getenv, readFile, &stderr)
-
-	if exitCode != 1 {
-		t.Errorf("exitCode = %d, want 1", exitCode)
-	}
-	if !strings.Contains(stderr.String(), "GITEA_EXTRA_HEADERS") {
-		t.Errorf("stderr = %q, want mention of GITEA_EXTRA_HEADERS", stderr.String())
-	}
-}

operation/issue/issue.go

@@ -55,9 +55,9 @@ var (
 
 	IssueReadTool = tool.NewDefinition(
 		IssueReadToolName,
-		"Read issue: details, comments, or labels.",
+		"Read issue: details, comments, labels, or the full discussion as Markdown.",
 		annotation.ReadOnly("Read issue details"),
-		tool.String("method", tool.Required(), tool.Enum("get", "get_comments", "get_labels")),
+		tool.String("method", tool.Required(), tool.Enum("get", "get_comments", "get_labels", "get_discussion_markdown")),
 		tool.String("owner", tool.Required(), tool.Description(params.OwnerDesc)),
 		tool.String("repo", tool.Required(), tool.Description(params.RepoDesc)),
 		tool.Number("issue_number", tool.Required()),
@@ -112,6 +112,8 @@ func issueReadFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult,
 		return getIssueCommentsByIndexFn(ctx, args)
 	case "get_labels":
 		return getIssueLabelsFn(ctx, args)
+	case "get_discussion_markdown":
+		return getIssueDiscussionMarkdownFn(ctx, args)
 	default:
 		return to.ErrorResult(fmt.Errorf("unknown method: %s", method))
 	}
@@ -398,6 +400,54 @@ func getIssueCommentsByIndexFn(ctx context.Context, args map[string]any) (*mcp.C
 	return to.TextResult(out)
 }
 
+func getIssueDiscussionMarkdownFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	index, err := params.GetIndex(args, "issue_number")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+
+	var issue issueWithAssets
+	issuePath := fmt.Sprintf("repos/%s/%s/issues/%d", url.PathEscape(owner), url.PathEscape(repo), index)
+	if _, err := gitea.DoJSON(ctx, "GET", issuePath, nil, nil, &issue); err != nil {
+		return to.ErrorResult(fmt.Errorf("get %v/%v/issue/%v err: %v", owner, repo, index, err))
+	}
+
+	var comments []commentWithAssets
+	commentsPath := fmt.Sprintf("repos/%s/%s/issues/%d/comments", url.PathEscape(owner), url.PathEscape(repo), index)
+	if _, err := gitea.DoJSON(ctx, "GET", commentsPath, nil, nil, &comments); err != nil {
+		return to.ErrorResult(fmt.Errorf("get %v/%v/issues/%v/comments err: %v", owner, repo, index, err))
+	}
+
+	discComments := make([]discussionComment, 0, len(comments))
+	for i := range comments {
+		discComments = append(discComments, discussionComment{
+			Author:    slim.UserLogin(comments[i].Poster),
+			CreatedAt: comments[i].Created,
+			Body:      slim.BodyWithAttachments(comments[i].Body, comments[i].Assets),
+		})
+	}
+
+	md := formatDiscussionMarkdown(discussionIssue{
+		Number:    issue.Index,
+		Title:     issue.Title,
+		Author:    slim.UserLogin(issue.Poster),
+		State:     string(issue.State),
+		Labels:    slim.LabelNames(issue.Labels),
+		Body:      slim.BodyWithAttachments(issue.Body, issue.Assets),
+		CreatedAt: issue.Created,
+	}, discComments)
+
+	return to.RawTextResult(md)
+}
+
 func getIssueLabelsFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
 	owner, err := params.GetString(args, "owner")
 	if err != nil {

operation/issue/issue_test.go

@@ -266,6 +266,119 @@ func Test_getIssueByIndexFn_includesAttachments(t *testing.T) {
 	}
 }
 
+func Test_getIssueDiscussionMarkdownFn(t *testing.T) {
+	const (
+		owner = "octo"
+		repo  = "demo"
+	)
+
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v1/version":
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"version":"1.12.0"}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/42", owner, repo):
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{
+				"number": 42,
+				"title": "bug with screenshot",
+				"body": "see attached",
+				"state": "open",
+				"user": {"login": "octocat"},
+				"labels": [{"name": "bug"}],
+				"created_at": "2026-01-02T15:04:05Z",
+				"assets": [
+					{"id": 1, "name": "shot.png", "size": 1024, "browser_download_url": "https://example/shot.png"}
+				]
+			}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/42/comments", owner, repo):
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`[
+				{"id": 1, "body": "see this", "user": {"login": "reviewer"}, "created_at": "2026-01-03T09:00:00Z", "assets": [
+					{"id": 9, "name": "log.txt", "size": 200, "browser_download_url": "https://example/log.txt"}
+				]}
+			]`))
+		default:
+			http.NotFound(w, r)
+		}
+	})
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	origHost, origToken, origVersion := flag.Host, flag.Token, flag.Version
+	flag.Host, flag.Token, flag.Version = server.URL, "", "test"
+	defer func() { flag.Host, flag.Token, flag.Version = origHost, origToken, origVersion }()
+
+	args := map[string]any{
+		"owner": owner, "repo": repo, "issue_number": float64(42),
+	}
+	res, err := getIssueDiscussionMarkdownFn(context.Background(), args)
+	if err != nil {
+		t.Fatalf("getIssueDiscussionMarkdownFn() error = %v", err)
+	}
+	if res.IsError {
+		t.Fatalf("unexpected error result: %v", res.Content)
+	}
+	body := res.Content[0].(*mcp.TextContent).Text
+	for _, want := range []string{
+		"# bug with screenshot (#42)",
+		"**Author:** octocat",
+		"**State:** open",
+		"**Labels:** bug",
+		"[shot.png](https://example/shot.png)",
+		"### reviewer on 2026-01-03T09:00:00Z",
+		"[log.txt](https://example/log.txt)",
+	} {
+		if !strings.Contains(body, want) {
+			t.Fatalf("expected markdown to contain %q, got:\n%s", want, body)
+		}
+	}
+}
+
+func Test_getIssueDiscussionMarkdownFn_noComments(t *testing.T) {
+	const (
+		owner = "octo"
+		repo  = "demo"
+	)
+
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v1/version":
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"version":"1.12.0"}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/7", owner, repo):
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"number": 7, "title": "quiet issue", "state": "open", "user": {"login": "octocat"}}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/issues/7/comments", owner, repo):
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`[]`))
+		default:
+			http.NotFound(w, r)
+		}
+	})
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	origHost, origToken, origVersion := flag.Host, flag.Token, flag.Version
+	flag.Host, flag.Token, flag.Version = server.URL, "", "test"
+	defer func() { flag.Host, flag.Token, flag.Version = origHost, origToken, origVersion }()
+
+	args := map[string]any{
+		"owner": owner, "repo": repo, "issue_number": float64(7),
+	}
+	res, err := getIssueDiscussionMarkdownFn(context.Background(), args)
+	if err != nil {
+		t.Fatalf("getIssueDiscussionMarkdownFn() error = %v", err)
+	}
+	if res.IsError {
+		t.Fatalf("unexpected error result: %v", res.Content)
+	}
+	body := res.Content[0].(*mcp.TextContent).Text
+	if !strings.Contains(body, "_No comments yet._") {
+		t.Fatalf("expected placeholder for no comments, got:\n%s", body)
+	}
+}
+
 func Test_getIssueCommentsByIndexFn_includesAttachments(t *testing.T) {
 	const (
 		owner = "octo"

operation/issue/markdown.go

@@ -0,0 +1,63 @@
+package issue
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+type discussionIssue struct {
+	Number    int64
+	Title     string
+	Author    string
+	State     string
+	Labels    []string
+	Body      string
+	CreatedAt time.Time
+}
+
+type discussionComment struct {
+	Author    string
+	CreatedAt time.Time
+	Body      string
+}
+
+// formatDiscussionMarkdown renders an issue and its comments as a single
+// Markdown document suitable for display without further parsing.
+func formatDiscussionMarkdown(issue discussionIssue, comments []discussionComment) string {
+	var b strings.Builder
+
+	fmt.Fprintf(&b, "# %s (#%d)\n\n", issue.Title, issue.Number)
+	fmt.Fprintf(&b, "**Author:** %s\n", issue.Author)
+	fmt.Fprintf(&b, "**State:** %s\n", issue.State)
+	if len(issue.Labels) > 0 {
+		fmt.Fprintf(&b, "**Labels:** %s\n", strings.Join(issue.Labels, ", "))
+	}
+	if !issue.CreatedAt.IsZero() {
+		fmt.Fprintf(&b, "**Created:** %s\n", issue.CreatedAt.UTC().Format(time.RFC3339))
+	}
+	b.WriteString("\n")
+	b.WriteString(strings.TrimSpace(issue.Body))
+	b.WriteString("\n\n---\n\n## Comments\n\n")
+
+	if len(comments) == 0 {
+		b.WriteString("_No comments yet._\n")
+		return b.String()
+	}
+
+	for i, c := range comments {
+		fmt.Fprintf(&b, "### %s", c.Author)
+		if !c.CreatedAt.IsZero() {
+			fmt.Fprintf(&b, " on %s", c.CreatedAt.UTC().Format(time.RFC3339))
+		}
+		b.WriteString("\n\n")
+		b.WriteString(strings.TrimSpace(c.Body))
+		if i < len(comments)-1 {
+			b.WriteString("\n\n---\n\n")
+		} else {
+			b.WriteString("\n")
+		}
+	}
+
+	return b.String()
+}

operation/issue/markdown_test.go

@@ -0,0 +1,85 @@
+package issue
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func Test_formatDiscussionMarkdown_includesIssueAndComments(t *testing.T) {
+	created := time.Date(2026, 1, 2, 15, 4, 5, 0, time.UTC)
+	commentTime := time.Date(2026, 1, 3, 9, 0, 0, 0, time.UTC)
+	md := formatDiscussionMarkdown(
+		discussionIssue{
+			Number:    42,
+			Title:     "bug with screenshot",
+			Author:    "octocat",
+			State:     "open",
+			Labels:    []string{"bug", "help wanted"},
+			Body:      "see attached",
+			CreatedAt: created,
+		},
+		[]discussionComment{
+			{Author: "reviewer", CreatedAt: commentTime, Body: "thanks for reporting"},
+		},
+	)
+
+	wantSubstrings := []string{
+		"# bug with screenshot (#42)",
+		"**Author:** octocat",
+		"**State:** open",
+		"**Labels:** bug, help wanted",
+		"**Created:** 2026-01-02T15:04:05Z",
+		"see attached",
+		"## Comments",
+		"### reviewer",
+		"2026-01-03T09:00:00Z",
+		"thanks for reporting",
+	}
+	for _, want := range wantSubstrings {
+		if !strings.Contains(md, want) {
+			t.Fatalf("expected markdown to contain %q, got:\n%s", want, md)
+		}
+	}
+}
+
+func Test_formatDiscussionMarkdown_noComments(t *testing.T) {
+	md := formatDiscussionMarkdown(
+		discussionIssue{
+			Number: 1,
+			Title:  "no comments yet",
+			Author: "octocat",
+			State:  "open",
+		},
+		nil,
+	)
+
+	if !strings.Contains(md, "## Comments") {
+		t.Fatalf("expected a Comments section, got:\n%s", md)
+	}
+	if !strings.Contains(md, "_No comments yet._") {
+		t.Fatalf("expected placeholder for no comments, got:\n%s", md)
+	}
+}
+
+func Test_formatDiscussionMarkdown_attachmentBodyIsInlined(t *testing.T) {
+	md := formatDiscussionMarkdown(
+		discussionIssue{
+			Number: 7,
+			Title:  "with attachment",
+			Author: "octocat",
+			State:  "open",
+			Body:   "see attached\n\n[shot.png](https://example/shot.png)",
+		},
+		[]discussionComment{
+			{Author: "reviewer", Body: "log attached\n\n[log.txt](https://example/log.txt)"},
+		},
+	)
+
+	if !strings.Contains(md, "[shot.png](https://example/shot.png)") {
+		t.Fatalf("expected issue attachment link in markdown, got:\n%s", md)
+	}
+	if !strings.Contains(md, "[log.txt](https://example/log.txt)") {
+		t.Fatalf("expected comment attachment link in markdown, got:\n%s", md)
+	}
+}

pkg/flag/flag.go

@@ -1,7 +1,5 @@
 package flag
 
-import "net/http"
-
 var (
 	Host    string
 	Bind    string
@@ -17,5 +15,4 @@ var (
 	Debug         bool
 	AllowedTools  map[string]struct{}
 	AllowedScopes map[string]struct{}
-	ExtraHeaders  http.Header
 )

pkg/gitea/gitea.go

@@ -30,32 +30,6 @@ func sharedTransport() *http.Transport {
 	return sharedTrans
 }
 
-// extraHeaderTransport injects flag.ExtraHeaders into every request, without
-// overriding headers the caller already set (e.g. Authorization, Content-Type,
-// Accept). It reads flag.ExtraHeaders on each round trip rather than caching
-// it, so tests can change it between requests.
-type extraHeaderTransport struct {
-	base http.RoundTripper
-}
-
-func (t *extraHeaderTransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	headers := flag.ExtraHeaders
-	if len(headers) == 0 {
-		return t.base.RoundTrip(req)
-	}
-	cloned := req.Clone(req.Context())
-	for name, values := range headers {
-		if cloned.Header.Get(name) == "" {
-			cloned.Header[name] = values
-		}
-	}
-	return t.base.RoundTrip(cloned)
-}
-
-func giteaTransport() http.RoundTripper {
-	return &extraHeaderTransport{base: sharedTransport()}
-}
-
 // NewClient returns a cached *gitea.Client keyed by host+token. The SDK's per-client
 // version cache and the shared transport let us reuse keep-alive connections
 // and avoid the SDK's /api/v1/version preflight on every tool call.
@@ -66,7 +40,7 @@ func NewClient(token string) (*gitea.Client, error) {
 	}
 
 	httpClient := &http.Client{
-		Transport:     giteaTransport(),
+		Transport:     sharedTransport(),
 		CheckRedirect: checkRedirect,
 	}
 	opts := []gitea.ClientOption{

pkg/gitea/gitea_test.go

@@ -1,49 +0,0 @@
-package gitea
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"gitea.com/gitea/gitea-mcp/pkg/flag"
-)
-
-func TestNewClient_SendsExtraHeaders(t *testing.T) {
-	var gotClientID, gotAuthorization string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotClientID = r.Header.Get("CF-Access-Client-Id")
-		gotAuthorization = r.Header.Get("Authorization")
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"login":"octocat"}`))
-	}))
-	defer srv.Close()
-
-	origHost := flag.Host
-	origExtraHeaders := flag.ExtraHeaders
-	defer func() {
-		flag.Host = origHost
-		flag.ExtraHeaders = origExtraHeaders
-	}()
-	flag.Host = srv.URL
-	flag.ExtraHeaders = http.Header{
-		"Cf-Access-Client-Id": []string{"client-id"},
-		"Authorization":       []string{"should-not-override"},
-	}
-
-	client, err := NewClient("the-token")
-	if err != nil {
-		t.Fatalf("NewClient returned error: %v", err)
-	}
-	if _, _, err := client.Users.GetMyUserInfo(context.Background()); err != nil {
-		t.Fatalf("GetMyUserInfo returned error: %v", err)
-	}
-
-	if gotClientID != "client-id" {
-		t.Fatalf("CF-Access-Client-Id header = %q, want %q", gotClientID, "client-id")
-	}
-	if gotAuthorization != "token the-token" {
-		t.Fatalf("Authorization header = %q, want %q", gotAuthorization, "token the-token")
-	}
-}

pkg/gitea/rest.go

@@ -59,7 +59,7 @@ var (
 func restHTTPClient() *http.Client {
 	restClientOnce.Do(func() {
 		restClient = &http.Client{
-			Transport:     giteaTransport(),
+			Transport:     sharedTransport(),
 			Timeout:       httpClientTimeout,
 			CheckRedirect: checkRedirect,
 		}
@@ -180,7 +180,7 @@ func DoJSON(ctx context.Context, method, path string, query url.Values, body, re
 
 func attachmentHTTPClient(origin *url.URL) *http.Client {
 	return &http.Client{
-		Transport: giteaTransport(),
+		Transport: sharedTransport(),
 		CheckRedirect: func(req *http.Request, via []*http.Request) error {
 			if err := checkRedirect(req, via); err != nil {
 				return err

pkg/gitea/rest_test.go

@@ -62,44 +62,3 @@ func TestDoJSON_LimitsErrorResponseBody(t *testing.T) {
 		t.Fatalf("expected body length %d, got %d", errBodySnippetSize, len(httpErr.Body))
 	}
 }
-
-func TestDoJSON_SendsExtraHeaders(t *testing.T) {
-	var gotClientID, gotAuthorization string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotClientID = r.Header.Get("CF-Access-Client-Id")
-		gotAuthorization = r.Header.Get("Authorization")
-		w.WriteHeader(http.StatusOK)
-		_, _ = io.WriteString(w, "{}")
-	}))
-	defer srv.Close()
-
-	origHost := flag.Host
-	origToken := flag.Token
-	origExtraHeaders := flag.ExtraHeaders
-	defer func() {
-		flag.Host = origHost
-		flag.Token = origToken
-		flag.ExtraHeaders = origExtraHeaders
-	}()
-	flag.Host = srv.URL
-	flag.Token = "the-token"
-	flag.ExtraHeaders = http.Header{
-		"Cf-Access-Client-Id": []string{"client-id"},
-		"Authorization":       []string{"should-not-override"},
-	}
-
-	var out map[string]any
-	status, err := DoJSON(context.Background(), http.MethodGet, "repos/owner/repo", nil, nil, &out)
-	if err != nil {
-		t.Fatalf("DoJSON returned error: %v", err)
-	}
-	if status != http.StatusOK {
-		t.Fatalf("expected status %d, got %d", http.StatusOK, status)
-	}
-	if gotClientID != "client-id" {
-		t.Fatalf("CF-Access-Client-Id header = %q, want %q", gotClientID, "client-id")
-	}
-	if gotAuthorization != "token the-token" {
-		t.Fatalf("Authorization header = %q, want %q", gotAuthorization, "token the-token")
-	}
-}

pkg/to/to.go

@@ -23,6 +23,17 @@ func TextResult(v any) (*mcp.CallToolResult, error) {
 	}, nil
 }
 
+// RawTextResult returns text as-is, without JSON-encoding it. Use it for
+// content that is already meant to be read directly, such as Markdown.
+func RawTextResult(text string) (*mcp.CallToolResult, error) {
+	if flag.Debug {
+		log.Debugf("Text Result: %s", text)
+	}
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{&mcp.TextContent{Text: text}},
+	}, nil
+}
+
 func ErrorResult(err error) (*mcp.CallToolResult, error) {
 	log.Errorf("%s", err.Error())
 	var result mcp.CallToolResult