Merge branch 'main' of github.com:mark3labs/mcp-go

Author: ezynda3

.github/workflows/ci.yml

@@ -4,6 +4,8 @@ on:
     branches:
       - main
   pull_request:
+  workflow_dispatch:
+
 jobs:
   test:
     runs-on: ubuntu-latest
@@ -13,3 +15,21 @@ jobs:
       with:
         go-version-file: 'go.mod'
     - run: go test ./... -race
+
+  verify-codegen:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with:
+        go-version-file: 'go.mod'
+    - name: Run code generation
+      run: go generate ./...
+    - name: Check for uncommitted changes
+      run: |
+        if [[ -n $(git status --porcelain) ]]; then
+          echo "Error: Generated code is not up to date. Please run 'go generate ./...' and commit the changes."
+          git status
+          git diff
+          exit 1
+        fi

client/inprocess_test.go

@@ -36,6 +36,11 @@ func TestInProcessMCPClient(t *testing.T) {
 					Type: "text",
 					Text: "Input parameter: " + request.Params.Arguments["parameter-1"].(string),
 				},
+				mcp.AudioContent{
+					Type:     "audio",
+					Data:     "base64-encoded-audio-data",
+					MIMEType: "audio/wav",
+				},
 			},
 		}, nil
 	})
@@ -77,6 +82,14 @@ func TestInProcessMCPClient(t *testing.T) {
 							Text: "Test prompt with arg1: " + request.Params.Arguments["arg1"],
 						},
 					},
+					{
+						Role: mcp.RoleUser,
+						Content: mcp.AudioContent{
+							Type:     "audio",
+							Data:     "base64-encoded-audio-data",
+							MIMEType: "audio/wav",
+						},
+					},
 				},
 			}, nil
 		},
@@ -192,8 +205,8 @@ func TestInProcessMCPClient(t *testing.T) {
 			t.Fatalf("CallTool failed: %v", err)
 		}
 
-		if len(result.Content) != 1 {
-			t.Errorf("Expected 1 content item, got %d", len(result.Content))
+		if len(result.Content) != 2 {
+			t.Errorf("Expected 2 content item, got %d", len(result.Content))
 		}
 	})
 
@@ -359,14 +372,17 @@ func TestInProcessMCPClient(t *testing.T) {
 
 		request := mcp.GetPromptRequest{}
 		request.Params.Name = "test-prompt"
+		request.Params.Arguments = map[string]string{
+			"arg1": "arg1 value",
+		}
 
 		result, err := client.GetPrompt(context.Background(), request)
 		if err != nil {
 			t.Errorf("GetPrompt failed: %v", err)
 		}
 
-		if len(result.Messages) != 1 {
-			t.Errorf("Expected 1 message, got %d", len(result.Messages))
+		if len(result.Messages) != 2 {
+			t.Errorf("Expected 2 message, got %d", len(result.Messages))
 		}
 	})
 

client/stdio_test.go

@@ -7,7 +7,7 @@ import (
 	"log/slog"
 	"os"
 	"os/exec"
-	"path/filepath"
+	"runtime"
 	"sync"
 	"testing"
 	"time"
@@ -19,24 +19,41 @@ func compileTestServer(outputPath string) error {
 	cmd := exec.Command(
 		"go",
 		"build",
+		"-buildmode=pie",
 		"-o",
 		outputPath,
 		"../testdata/mockstdio_server.go",
 	)
+	tmpCache, _ := os.MkdirTemp("", "gocache")
+	cmd.Env = append(os.Environ(), "GOCACHE="+tmpCache)
+
 	if output, err := cmd.CombinedOutput(); err != nil {
 		return fmt.Errorf("compilation failed: %v\nOutput: %s", err, output)
 	}
+	// Verify the binary was actually created
 	if _, err := os.Stat(outputPath); os.IsNotExist(err) {
 		return fmt.Errorf("mock server binary not found at %s after compilation", outputPath)
 	}
 	return nil
 }
 
 func TestStdioMCPClient(t *testing.T) {
-	// Compile mock server
-	mockServerPath := filepath.Join(os.TempDir(), "mockstdio_server")
-	if err := compileTestServer(mockServerPath); err != nil {
-		t.Fatalf("Failed to compile mock server: %v", err)
+	// Create a temporary file for the mock server
+	tempFile, err := os.CreateTemp("", "mockstdio_server")
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	tempFile.Close()
+	mockServerPath := tempFile.Name()
+
+	// Add .exe suffix on Windows
+	if runtime.GOOS == "windows" {
+		os.Remove(mockServerPath) // Remove the empty file first
+		mockServerPath += ".exe"
+	}
+
+	if compileErr := compileTestServer(mockServerPath); compileErr != nil {
+		t.Fatalf("Failed to compile mock server: %v", compileErr)
 	}
 	defer os.Remove(mockServerPath)
 

client/transport/stdio_test.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"path/filepath"
 	"runtime"
 	"sync"
 	"testing"
@@ -19,25 +18,41 @@ func compileTestServer(outputPath string) error {
 	cmd := exec.Command(
 		"go",
 		"build",
+		"-buildmode=pie",
 		"-o",
 		outputPath,
 		"../../testdata/mockstdio_server.go",
 	)
+	tmpCache, _ := os.MkdirTemp("", "gocache")
+	cmd.Env = append(os.Environ(), "GOCACHE="+tmpCache)
+
 	if output, err := cmd.CombinedOutput(); err != nil {
 		return fmt.Errorf("compilation failed: %v\nOutput: %s", err, output)
 	}
+	// Verify the binary was actually created
+	if _, err := os.Stat(outputPath); os.IsNotExist(err) {
+		return fmt.Errorf("mock server binary not found at %s after compilation", outputPath)
+	}
 	return nil
 }
 
 func TestStdio(t *testing.T) {
-	// Compile mock server
-	mockServerPath := filepath.Join(os.TempDir(), "mockstdio_server")
+	// Create a temporary file for the mock server
+	tempFile, err := os.CreateTemp("", "mockstdio_server")
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	tempFile.Close()
+	mockServerPath := tempFile.Name()
+
 	// Add .exe suffix on Windows
 	if runtime.GOOS == "windows" {
+		os.Remove(mockServerPath) // Remove the empty file first
 		mockServerPath += ".exe"
 	}
-	if err := compileTestServer(mockServerPath); err != nil {
-		t.Fatalf("Failed to compile mock server: %v", err)
+
+	if compileErr := compileTestServer(mockServerPath); compileErr != nil {
+		t.Fatalf("Failed to compile mock server: %v", compileErr)
 	}
 	defer os.Remove(mockServerPath)
 
@@ -48,9 +63,9 @@ func TestStdio(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 
-	err := stdio.Start(ctx)
-	if err != nil {
-		t.Fatalf("Failed to start Stdio transport: %v", err)
+	startErr := stdio.Start(ctx)
+	if startErr != nil {
+		t.Fatalf("Failed to start Stdio transport: %v", startErr)
 	}
 	defer stdio.Close()
 
@@ -307,13 +322,22 @@ func TestStdioErrors(t *testing.T) {
 	})
 
 	t.Run("RequestBeforeStart", func(t *testing.T) {
-		mockServerPath := filepath.Join(os.TempDir(), "mockstdio_server")
+		// Create a temporary file for the mock server
+		tempFile, err := os.CreateTemp("", "mockstdio_server")
+		if err != nil {
+			t.Fatalf("Failed to create temp file: %v", err)
+		}
+		tempFile.Close()
+		mockServerPath := tempFile.Name()
+
 		// Add .exe suffix on Windows
 		if runtime.GOOS == "windows" {
+			os.Remove(mockServerPath) // Remove the empty file first
 			mockServerPath += ".exe"
 		}
-		if err := compileTestServer(mockServerPath); err != nil {
-			t.Fatalf("Failed to compile mock server: %v", err)
+
+		if compileErr := compileTestServer(mockServerPath); compileErr != nil {
+			t.Fatalf("Failed to compile mock server: %v", compileErr)
 		}
 		defer os.Remove(mockServerPath)
 
@@ -328,23 +352,31 @@ func TestStdioErrors(t *testing.T) {
 
 		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
 		defer cancel()
-		_, err := uninitiatedStdio.SendRequest(ctx, request)
-		if err == nil {
+		_, reqErr := uninitiatedStdio.SendRequest(ctx, request)
+		if reqErr == nil {
 			t.Errorf("Expected SendRequest to panic before Start(), but it didn't")
-		} else if err.Error() != "stdio client not started" {
-			t.Errorf("Expected error 'stdio client not started', got: %v", err)
+		} else if reqErr.Error() != "stdio client not started" {
+			t.Errorf("Expected error 'stdio client not started', got: %v", reqErr)
 		}
 	})
 
 	t.Run("RequestAfterClose", func(t *testing.T) {
-		// Compile mock server
-		mockServerPath := filepath.Join(os.TempDir(), "mockstdio_server")
+		// Create a temporary file for the mock server
+		tempFile, err := os.CreateTemp("", "mockstdio_server")
+		if err != nil {
+			t.Fatalf("Failed to create temp file: %v", err)
+		}
+		tempFile.Close()
+		mockServerPath := tempFile.Name()
+
 		// Add .exe suffix on Windows
 		if runtime.GOOS == "windows" {
+			os.Remove(mockServerPath) // Remove the empty file first
 			mockServerPath += ".exe"
 		}
-		if err := compileTestServer(mockServerPath); err != nil {
-			t.Fatalf("Failed to compile mock server: %v", err)
+
+		if compileErr := compileTestServer(mockServerPath); compileErr != nil {
+			t.Fatalf("Failed to compile mock server: %v", compileErr)
 		}
 		defer os.Remove(mockServerPath)
 
@@ -353,8 +385,8 @@ func TestStdioErrors(t *testing.T) {
 
 		// Start the transport
 		ctx := context.Background()
-		if err := stdio.Start(ctx); err != nil {
-			t.Fatalf("Failed to start Stdio transport: %v", err)
+		if startErr := stdio.Start(ctx); startErr != nil {
+			t.Fatalf("Failed to start Stdio transport: %v", startErr)
 		}
 
 		// Close the transport - ignore errors like "broken pipe" since the process might exit already
@@ -370,8 +402,8 @@ func TestStdioErrors(t *testing.T) {
 			Method:  "ping",
 		}
 
-		_, err := stdio.SendRequest(ctx, request)
-		if err == nil {
+		_, sendErr := stdio.SendRequest(ctx, request)
+		if sendErr == nil {
 			t.Errorf("Expected error when sending request after close, got nil")
 		}
 	})

mcp/prompts.go

@@ -78,7 +78,7 @@ const (
 // resources from the MCP server.
 type PromptMessage struct {
 	Role    Role    `json:"role"`
-	Content Content `json:"content"` // Can be TextContent, ImageContent, or EmbeddedResource
+	Content Content `json:"content"` // Can be TextContent, ImageContent, AudioContent or EmbeddedResource
 }
 
 // PromptListChangedNotification is an optional notification from the server

mcp/tools.go

@@ -33,7 +33,7 @@ type ListToolsResult struct {
 // should be reported as an MCP error response.
 type CallToolResult struct {
 	Result
-	Content []Content `json:"content"` // Can be TextContent, ImageContent, or      EmbeddedResource
+	Content []Content `json:"content"` // Can be TextContent, ImageContent, AudioContent, or EmbeddedResource
 	// Whether the tool call ended in an error.
 	//
 	// If not set, this is assumed to be false (the call was successful).

mcp/types.go

@@ -132,7 +132,7 @@ type NotificationParams struct {
 }
 
 // MarshalJSON implements custom JSON marshaling
-func (p *NotificationParams) MarshalJSON() ([]byte, error) {
+func (p NotificationParams) MarshalJSON() ([]byte, error) {
 	// Create a map to hold all fields
 	m := make(map[string]interface{})
 
@@ -656,7 +656,7 @@ type CreateMessageResult struct {
 // SamplingMessage describes a message issued to or received from an LLM API.
 type SamplingMessage struct {
 	Role    Role        `json:"role"`
-	Content interface{} `json:"content"` // Can be TextContent or ImageContent
+	Content interface{} `json:"content"` // Can be TextContent, ImageContent or AudioContent
 }
 
 type Annotations struct {
@@ -709,6 +709,19 @@ type ImageContent struct {
 
 func (ImageContent) isContent() {}
 
+// AudioContent represents the contents of audio, embedded into a prompt or tool call result.
+// It must have Type set to "audio".
+type AudioContent struct {
+	Annotated
+	Type string `json:"type"` // Must be "audio"
+	// The base64-encoded audio data.
+	Data string `json:"data"`
+	// The MIME type of the audio. Different providers may support different audio types.
+	MIMEType string `json:"mimeType"`
+}
+
+func (AudioContent) isContent() {}
+
 // EmbeddedResource represents the contents of a resource, embedded into a prompt or tool call result.
 //
 // It is up to the client how best to render embedded resources for the