mcp: implement sampling with tools (#699)
Summary Add support for tool use within sampling requests, as described in the MCP 2025-11-25 spec's sampling.tools capability. New types Content types: - ToolUseContent — represents a tool invocation request from the assistant - ToolResultContent — represents the result of a tool invocation, with nested []Content for the result blocks Capability types: - SamplingCapabilities gains Tools and Context sub-fields - SamplingToolsCapabilities, SamplingContextCapabilities Tool-enabled sampling (parallel tool calls): - CreateMessageWithToolsParams with SamplingMessageV2 (supports array content) - CreateMessageWithToolsResult (supports array content) - ToolChoice — controls tool invocation mode (auto, required, none) - ServerSession.CreateMessageWithTools - ClientOptions.CreateMessageWithToolsHandler Design Following the TypeScript SDK's pattern, tool-enabled sampling uses separate types from basic sampling to avoid breaking the existing API. The basic CreateMessage/CreateMessageResult path is unchanged. Both paths share the same wire method (sampling/createMessage) and go through the method info table. The table uses the broader CreateMessageWithToolsResult type internally; CreateMessage downconverts (erroring if multiple content blocks are returned). This is documented as a rough edge to unify in v2. Setting CreateMessageWithToolsHandler automatically infers the sampling.tools capability. It is a panic to set both CreateMessageHandler and CreateMessageWithToolsHandler. References - https://modelcontextprotocol.io/specification/2025-11-25/client/sampling - TypeScript SDK: CreateMessageResultWithToolsSchema / CreateMessageRequestParamsWithTools --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Robert Findley
GitHub
parent
14869a46ee
commit
3cf9f9908d
1 changed files with 1641 additions and 38 deletions
546
mcp/sampling_test.go
Normal file
546
mcp/sampling_test.go
Normal file
|
|
@ -0,0 +1,546 @@
|
|||
// Copyright 2025 The Go MCP SDK Authors. All rights reserved.
|
||||
// Use of this source code is governed by an MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package mcp
|
||||
|
||||
// TODO: move other sampling-related tests to this file.
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestSamplingWithTools_Integration(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
ct, st := NewInMemoryTransports()
|
||||
|
||||
// Track what the client received
|
||||
var receivedParams *CreateMessageWithToolsParams
|
||||
|
||||
// Client with tools capability, using CreateMessageWithToolsHandler
|
||||
client := NewClient(testImpl, &ClientOptions{
|
||||
CreateMessageWithToolsHandler: func(_ context.Context, req *CreateMessageWithToolsRequest) (*CreateMessageWithToolsResult, error) {
|
||||
receivedParams = req.Params
|
||||
// Return a tool use response
|
||||
return &CreateMessageWithToolsResult{
|
||||
Model: "test-model",
|
||||
Role: "assistant",
|
||||
Content: []Content{&ToolUseContent{
|
||||
ID: "tool_call_1",
|
||||
Name: "calculator",
|
||||
Input: map[string]any{"x": 1.0, "y": 2.0},
|
||||
}},
|
||||
StopReason: "toolUse",
|
||||
}, nil
|
||||
},
|
||||
Capabilities: &ClientCapabilities{
|
||||
Sampling: &SamplingCapabilities{Tools: &SamplingToolsCapabilities{}},
|
||||
},
|
||||
})
|
||||
|
||||
server := NewServer(testImpl, nil)
|
||||
ss, err := server.Connect(ctx, st, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer ss.Close()
|
||||
|
||||
cs, err := client.Connect(ctx, ct, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer cs.Close()
|
||||
|
||||
// Server sends CreateMessageWithTools
|
||||
result, err := ss.CreateMessageWithTools(ctx, &CreateMessageWithToolsParams{
|
||||
MaxTokens: 1000,
|
||||
Messages: []*SamplingMessageV2{
|
||||
{Role: "user", Content: []Content{&TextContent{Text: "Calculate 1+2"}}},
|
||||
},
|
||||
Tools: []*Tool{
|
||||
{
|
||||
Name: "calculator",
|
||||
Description: "A calculator",
|
||||
InputSchema: map[string]any{
|
||||
"type": "object",
|
||||
"properties": map[string]any{
|
||||
"x": map[string]any{"type": "number"},
|
||||
"y": map[string]any{"type": "number"},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
ToolChoice: &ToolChoice{Mode: "auto"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateMessageWithTools() error = %v", err)
|
||||
}
|
||||
|
||||
// Verify client received the tools
|
||||
if receivedParams == nil {
|
||||
t.Fatal("client did not receive params")
|
||||
}
|
||||
if len(receivedParams.Tools) != 1 {
|
||||
t.Errorf("client received %d tools, want 1", len(receivedParams.Tools))
|
||||
}
|
||||
if receivedParams.Tools[0].Name != "calculator" {
|
||||
t.Errorf("tool name = %v, want calculator", receivedParams.Tools[0].Name)
|
||||
}
|
||||
if receivedParams.ToolChoice == nil || receivedParams.ToolChoice.Mode != "auto" {
|
||||
t.Errorf("tool choice mode = %v, want auto", receivedParams.ToolChoice)
|
||||
}
|
||||
|
||||
// Verify server received the tool use response
|
||||
if result.StopReason != "toolUse" {
|
||||
t.Errorf("StopReason = %v, want toolUse", result.StopReason)
|
||||
}
|
||||
if len(result.Content) != 1 {
|
||||
t.Fatalf("len(Content) = %d, want 1", len(result.Content))
|
||||
}
|
||||
toolUse, ok := result.Content[0].(*ToolUseContent)
|
||||
if !ok {
|
||||
t.Fatalf("Content[0] type = %T, want *ToolUseContent", result.Content[0])
|
||||
}
|
||||
if toolUse.ID != "tool_call_1" {
|
||||
t.Errorf("ToolUse.ID = %v, want tool_call_1", toolUse.ID)
|
||||
}
|
||||
if toolUse.Name != "calculator" {
|
||||
t.Errorf("ToolUse.Name = %v, want calculator", toolUse.Name)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSamplingWithToolResult_Integration(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
ct, st := NewInMemoryTransports()
|
||||
|
||||
// Track messages received by client
|
||||
var receivedMessages []*SamplingMessage
|
||||
|
||||
client := NewClient(testImpl, &ClientOptions{
|
||||
CreateMessageHandler: func(_ context.Context, req *CreateMessageRequest) (*CreateMessageResult, error) {
|
||||
receivedMessages = req.Params.Messages
|
||||
return &CreateMessageResult{
|
||||
Model: "test-model",
|
||||
Role: "assistant",
|
||||
Content: &TextContent{Text: "The result is 3"},
|
||||
}, nil
|
||||
},
|
||||
Capabilities: &ClientCapabilities{
|
||||
Sampling: &SamplingCapabilities{Tools: &SamplingToolsCapabilities{}},
|
||||
},
|
||||
})
|
||||
|
||||
server := NewServer(testImpl, nil)
|
||||
ss, err := server.Connect(ctx, st, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer ss.Close()
|
||||
|
||||
cs, err := client.Connect(ctx, ct, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer cs.Close()
|
||||
|
||||
// Server sends CreateMessage with tool result in messages
|
||||
_, err = ss.CreateMessage(ctx, &CreateMessageParams{
|
||||
MaxTokens: 1000,
|
||||
Messages: []*SamplingMessage{
|
||||
{Role: "user", Content: &TextContent{Text: "Calculate 1+2"}},
|
||||
{Role: "assistant", Content: &ToolUseContent{
|
||||
ID: "tool_1",
|
||||
Name: "calculator",
|
||||
Input: map[string]any{"x": 1.0, "y": 2.0},
|
||||
}},
|
||||
{Role: "user", Content: &ToolResultContent{
|
||||
ToolUseID: "tool_1",
|
||||
Content: []Content{&TextContent{Text: "3"}},
|
||||
}},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateMessage() error = %v", err)
|
||||
}
|
||||
|
||||
// Verify client received all messages including tool content
|
||||
if len(receivedMessages) != 3 {
|
||||
t.Fatalf("received %d messages, want 3", len(receivedMessages))
|
||||
}
|
||||
|
||||
// Check first message is text
|
||||
if _, ok := receivedMessages[0].Content.(*TextContent); !ok {
|
||||
t.Errorf("message[0] content type = %T, want *TextContent", receivedMessages[0].Content)
|
||||
}
|
||||
|
||||
// Check second message is tool use
|
||||
toolUse, ok := receivedMessages[1].Content.(*ToolUseContent)
|
||||
if !ok {
|
||||
t.Fatalf("message[1] content type = %T, want *ToolUseContent", receivedMessages[1].Content)
|
||||
}
|
||||
if toolUse.ID != "tool_1" {
|
||||
t.Errorf("toolUse.ID = %v, want tool_1", toolUse.ID)
|
||||
}
|
||||
|
||||
// Check third message is tool result
|
||||
toolResult, ok := receivedMessages[2].Content.(*ToolResultContent)
|
||||
if !ok {
|
||||
t.Fatalf("message[2] content type = %T, want *ToolResultContent", receivedMessages[2].Content)
|
||||
}
|
||||
if toolResult.ToolUseID != "tool_1" {
|
||||
t.Errorf("toolResult.ToolUseID = %v, want tool_1", toolResult.ToolUseID)
|
||||
}
|
||||
if len(toolResult.Content) != 1 {
|
||||
t.Fatalf("toolResult.Content len = %d, want 1", len(toolResult.Content))
|
||||
}
|
||||
if tc, ok := toolResult.Content[0].(*TextContent); !ok || tc.Text != "3" {
|
||||
t.Errorf("toolResult.Content[0] = %v, want TextContent with '3'", toolResult.Content[0])
|
||||
}
|
||||
}
|
||||
|
||||
func TestSamplingToolsCapabilities(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
|
||||
t.Run("client with explicit tools capability", func(t *testing.T) {
|
||||
ct, st := NewInMemoryTransports()
|
||||
|
||||
client := NewClient(testImpl, &ClientOptions{
|
||||
CreateMessageHandler: func(_ context.Context, _ *CreateMessageRequest) (*CreateMessageResult, error) {
|
||||
return &CreateMessageResult{Model: "m", Content: &TextContent{}}, nil
|
||||
},
|
||||
Capabilities: &ClientCapabilities{
|
||||
Sampling: &SamplingCapabilities{
|
||||
Tools: &SamplingToolsCapabilities{},
|
||||
Context: &SamplingContextCapabilities{},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
server := NewServer(testImpl, nil)
|
||||
ss, err := server.Connect(ctx, st, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer ss.Close()
|
||||
|
||||
cs, err := client.Connect(ctx, ct, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer cs.Close()
|
||||
|
||||
// Check server sees client capabilities
|
||||
caps := ss.InitializeParams().Capabilities
|
||||
if caps.Sampling == nil {
|
||||
t.Fatal("client should advertise sampling capability")
|
||||
}
|
||||
if caps.Sampling.Tools == nil {
|
||||
t.Error("client should advertise sampling.tools capability")
|
||||
}
|
||||
if caps.Sampling.Context == nil {
|
||||
t.Error("client should advertise sampling.context capability")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("client without tools capability", func(t *testing.T) {
|
||||
ct, st := NewInMemoryTransports()
|
||||
|
||||
client := NewClient(testImpl, &ClientOptions{
|
||||
CreateMessageHandler: func(_ context.Context, _ *CreateMessageRequest) (*CreateMessageResult, error) {
|
||||
return &CreateMessageResult{Model: "m", Content: &TextContent{}}, nil
|
||||
},
|
||||
// No Capabilities.Sampling.Tools set
|
||||
})
|
||||
|
||||
server := NewServer(testImpl, nil)
|
||||
ss, err := server.Connect(ctx, st, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer ss.Close()
|
||||
|
||||
cs, err := client.Connect(ctx, ct, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer cs.Close()
|
||||
|
||||
// Check server sees client capabilities
|
||||
caps := ss.InitializeParams().Capabilities
|
||||
if caps.Sampling == nil {
|
||||
t.Fatal("client should advertise sampling capability")
|
||||
}
|
||||
if caps.Sampling.Tools != nil {
|
||||
t.Error("client should NOT advertise sampling.tools capability")
|
||||
}
|
||||
if caps.Sampling.Context != nil {
|
||||
t.Error("client should NOT advertise sampling.context capability")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("client with inferred tools capability", func(t *testing.T) {
|
||||
ct, st := NewInMemoryTransports()
|
||||
|
||||
client := NewClient(testImpl, &ClientOptions{
|
||||
CreateMessageWithToolsHandler: func(_ context.Context, _ *CreateMessageWithToolsRequest) (*CreateMessageWithToolsResult, error) {
|
||||
return &CreateMessageWithToolsResult{Model: "m", Content: []Content{&TextContent{}}}, nil
|
||||
},
|
||||
// No explicit Capabilities set — tools should be inferred.
|
||||
})
|
||||
|
||||
server := NewServer(testImpl, nil)
|
||||
ss, err := server.Connect(ctx, st, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer ss.Close()
|
||||
|
||||
cs, err := client.Connect(ctx, ct, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer cs.Close()
|
||||
|
||||
caps := ss.InitializeParams().Capabilities
|
||||
if caps.Sampling == nil {
|
||||
t.Fatal("client should advertise sampling capability")
|
||||
}
|
||||
if caps.Sampling.Tools == nil {
|
||||
t.Error("client should infer sampling.tools capability from CreateMessageWithToolsHandler")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestSamplingToolResultWithError_Integration(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
ct, st := NewInMemoryTransports()
|
||||
|
||||
var receivedMessages []*SamplingMessage
|
||||
|
||||
client := NewClient(testImpl, &ClientOptions{
|
||||
CreateMessageHandler: func(_ context.Context, req *CreateMessageRequest) (*CreateMessageResult, error) {
|
||||
receivedMessages = req.Params.Messages
|
||||
return &CreateMessageResult{
|
||||
Model: "test-model",
|
||||
Role: "assistant",
|
||||
Content: &TextContent{Text: "I see the tool failed"},
|
||||
}, nil
|
||||
},
|
||||
Capabilities: &ClientCapabilities{
|
||||
Sampling: &SamplingCapabilities{Tools: &SamplingToolsCapabilities{}},
|
||||
},
|
||||
})
|
||||
|
||||
server := NewServer(testImpl, nil)
|
||||
ss, err := server.Connect(ctx, st, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer ss.Close()
|
||||
|
||||
cs, err := client.Connect(ctx, ct, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer cs.Close()
|
||||
|
||||
// Server sends CreateMessage with error tool result, preceded by
|
||||
// the original request and tool use for a more realistic scenario.
|
||||
_, err = ss.CreateMessage(ctx, &CreateMessageParams{
|
||||
MaxTokens: 1000,
|
||||
Messages: []*SamplingMessage{
|
||||
{Role: "user", Content: &TextContent{Text: "Divide 1 by 0"}},
|
||||
{Role: "assistant", Content: &ToolUseContent{
|
||||
ID: "tool_1",
|
||||
Name: "calculator",
|
||||
Input: map[string]any{"op": "div", "x": 1.0, "y": 0.0},
|
||||
}},
|
||||
{Role: "user", Content: &ToolResultContent{
|
||||
ToolUseID: "tool_1",
|
||||
Content: []Content{&TextContent{Text: "division by zero"}},
|
||||
IsError: true,
|
||||
}},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateMessage() error = %v", err)
|
||||
}
|
||||
|
||||
if len(receivedMessages) != 3 {
|
||||
t.Fatalf("received %d messages, want 3", len(receivedMessages))
|
||||
}
|
||||
|
||||
toolResult, ok := receivedMessages[2].Content.(*ToolResultContent)
|
||||
if !ok {
|
||||
t.Fatalf("content type = %T, want *ToolResultContent", receivedMessages[2].Content)
|
||||
}
|
||||
if !toolResult.IsError {
|
||||
t.Error("IsError should be true")
|
||||
}
|
||||
if toolResult.ToolUseID != "tool_1" {
|
||||
t.Errorf("ToolUseID = %v, want tool_1", toolResult.ToolUseID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParallelToolCalls_Integration(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
ct, st := NewInMemoryTransports()
|
||||
|
||||
// Client returns parallel tool use results
|
||||
client := NewClient(testImpl, &ClientOptions{
|
||||
CreateMessageWithToolsHandler: func(_ context.Context, req *CreateMessageWithToolsRequest) (*CreateMessageWithToolsResult, error) {
|
||||
return &CreateMessageWithToolsResult{
|
||||
Model: "test-model",
|
||||
Role: "assistant",
|
||||
Content: []Content{
|
||||
&ToolUseContent{ID: "call_1", Name: "weather", Input: map[string]any{"city": "SF"}},
|
||||
&ToolUseContent{ID: "call_2", Name: "weather", Input: map[string]any{"city": "NY"}},
|
||||
},
|
||||
StopReason: "toolUse",
|
||||
}, nil
|
||||
},
|
||||
Capabilities: &ClientCapabilities{
|
||||
Sampling: &SamplingCapabilities{Tools: &SamplingToolsCapabilities{}},
|
||||
},
|
||||
})
|
||||
|
||||
server := NewServer(testImpl, nil)
|
||||
ss, err := server.Connect(ctx, st, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer ss.Close()
|
||||
|
||||
cs, err := client.Connect(ctx, ct, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer cs.Close()
|
||||
|
||||
result, err := ss.CreateMessageWithTools(ctx, &CreateMessageWithToolsParams{
|
||||
MaxTokens: 1000,
|
||||
Messages: []*SamplingMessageV2{
|
||||
{Role: "user", Content: []Content{&TextContent{Text: "Weather in SF and NY"}}},
|
||||
},
|
||||
Tools: []*Tool{
|
||||
{Name: "weather", InputSchema: map[string]any{"type": "object"}},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateMessageWithTools() error = %v", err)
|
||||
}
|
||||
|
||||
if len(result.Content) != 2 {
|
||||
t.Fatalf("len(Content) = %d, want 2", len(result.Content))
|
||||
}
|
||||
for i, c := range result.Content {
|
||||
tu, ok := c.(*ToolUseContent)
|
||||
if !ok {
|
||||
t.Fatalf("Content[%d] type = %T, want *ToolUseContent", i, c)
|
||||
}
|
||||
if tu.Name != "weather" {
|
||||
t.Errorf("Content[%d].Name = %v, want weather", i, tu.Name)
|
||||
}
|
||||
}
|
||||
if result.Content[0].(*ToolUseContent).ID != "call_1" {
|
||||
t.Errorf("Content[0].ID = %v, want call_1", result.Content[0].(*ToolUseContent).ID)
|
||||
}
|
||||
if result.Content[1].(*ToolUseContent).ID != "call_2" {
|
||||
t.Errorf("Content[1].ID = %v, want call_2", result.Content[1].(*ToolUseContent).ID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewClient_BothHandlersPanics(t *testing.T) {
|
||||
defer func() {
|
||||
r := recover()
|
||||
if r == nil {
|
||||
t.Fatal("expected panic when both handlers set")
|
||||
}
|
||||
msg, ok := r.(string)
|
||||
if !ok || !strings.Contains(msg, "CreateMessageHandler") {
|
||||
t.Errorf("unexpected panic: %v", r)
|
||||
}
|
||||
}()
|
||||
NewClient(testImpl, &ClientOptions{
|
||||
CreateMessageHandler: func(context.Context, *CreateMessageRequest) (*CreateMessageResult, error) {
|
||||
return nil, nil
|
||||
},
|
||||
CreateMessageWithToolsHandler: func(context.Context, *CreateMessageWithToolsRequest) (*CreateMessageWithToolsResult, error) {
|
||||
return nil, nil
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
func TestCreateMessage_MultipleContentError(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
ct, st := NewInMemoryTransports()
|
||||
|
||||
// Client returns multiple content blocks via CreateMessageWithToolsHandler
|
||||
client := NewClient(testImpl, &ClientOptions{
|
||||
CreateMessageWithToolsHandler: func(_ context.Context, _ *CreateMessageWithToolsRequest) (*CreateMessageWithToolsResult, error) {
|
||||
return &CreateMessageWithToolsResult{
|
||||
Model: "test",
|
||||
Role: "assistant",
|
||||
Content: []Content{
|
||||
&TextContent{Text: "a"},
|
||||
&TextContent{Text: "b"},
|
||||
},
|
||||
}, nil
|
||||
},
|
||||
})
|
||||
|
||||
server := NewServer(testImpl, nil)
|
||||
ss, err := server.Connect(ctx, st, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer ss.Close()
|
||||
|
||||
cs, err := client.Connect(ctx, ct, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer cs.Close()
|
||||
|
||||
// Server calls CreateMessage (singular), should get error
|
||||
_, err = ss.CreateMessage(ctx, &CreateMessageParams{
|
||||
MaxTokens: 100,
|
||||
Messages: []*SamplingMessage{{Role: "user", Content: &TextContent{Text: "hi"}}},
|
||||
})
|
||||
if err == nil {
|
||||
t.Fatal("expected error for multiple content blocks")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "CreateMessageWithTools") {
|
||||
t.Errorf("error should mention CreateMessageWithTools, got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientCapabilities_CloneSampling(t *testing.T) {
|
||||
caps := &ClientCapabilities{
|
||||
Sampling: &SamplingCapabilities{
|
||||
Tools: &SamplingToolsCapabilities{},
|
||||
Context: &SamplingContextCapabilities{},
|
||||
},
|
||||
}
|
||||
cloned := caps.clone()
|
||||
|
||||
// Verify deep copy — Sampling pointer should differ.
|
||||
// (Tools and Context are empty structs, so Go may reuse the same address;
|
||||
// we just check they're non-nil and that mutating Sampling doesn't alias.)
|
||||
if cloned.Sampling == caps.Sampling {
|
||||
t.Error("Sampling pointer should differ after clone")
|
||||
}
|
||||
if cloned.Sampling.Tools == nil {
|
||||
t.Error("cloned Sampling.Tools should not be nil")
|
||||
}
|
||||
if cloned.Sampling.Context == nil {
|
||||
t.Error("cloned Sampling.Context should not be nil")
|
||||
}
|
||||
// Verify mutation doesn't affect original.
|
||||
cloned.Sampling.Tools = nil
|
||||
if caps.Sampling.Tools == nil {
|
||||
t.Error("modifying cloned Sampling.Tools should not affect original")
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue