Fix the tool-use loop in the Go, Rust, and Ruby clients and add a tool-loop smoke test (#200)
Some checks failed
Smoke Tests / test (push) Has been cancelled
Some checks failed
Smoke Tests / test (push) Has been cancelled
* Fix the tool-use loop in the Go, Rust, and Ruby clients and add a tool-loop smoke test ## Motivation and Context Only the Python and TypeScript clients implemented a correct tool-use loop. The other three had bugs that break ordinary multi-step requests: - **Go, Rust, Ruby** did a single tool round and then called Claude once more *without* `tools`, so any request that needs a second tool call stalled. Go silently dropped `tool_use` blocks from that final response. - **Ruby** called Claude once per `tool_use` block, each time with a single `tool_result`. Parallel tool calls produced a malformed message sequence and an API 400. - **max_tokens** was 1000 in TypeScript and Ruby, 1024 in Go, and unset in Rust. Sonnet 5 thinks adaptively, so 1000 tokens is regularly exhausted mid-thought. Python already used 10000 with a comment explaining why. - **Ruby** never forwarded MCP `isError` as `is_error`, so the model could not tell a failed tool call from a successful one. Rust cannot set the flag either (see below). - **TypeScript** forwarded raw MCP content blocks to Anthropic. The two block shapes differ, so a non-text result would have failed. The existing smoke test never noticed because it only checks that each client calls `tools/list`. None of these bugs was reachable without an API key. ### What changed All five clients now run the same loop: call tools until Claude answers without one, send every `tool_result` of a turn in one user message, pass `tools` on every call, and stop after `MAX_TOOL_TURNS = 10`. `max_tokens` is 10000 everywhere, with the same comment. Python and TypeScript also keep the last response's text when the turn cap is hit; it used to be dropped. Rust keeps the `genai` crate. Its tool-response type has no `is_error` field, so an error result is marked with an `Error:` prefix in the text and the limitation is commented. ### New smoke test `tests/helpers/tool-loop-test.ts` starts a fake Anthropic Messages API on a loopback port, points a client at it through `ANTHROPIC_BASE_URL`, pipes in one query, and checks every request the client sends. It scripts two parallel tool calls, then a call to a tool the mock server lacks (an `isError` result), then a final answer, and asserts that tools are passed each time, `max_tokens` is 10000, all `tool_result`s arrive in one message with matching ids, and the error is forwarded. `smoke-test.sh` runs it for Python, TypeScript, Go, and Ruby. The Rust client is excluded for now: `genai` reads no endpoint variable, and the client negotiates protocol `2025-11-25`, under which the mock's array-rooted tool is refused at call time. Both will be addressed in a follow-up that brings all examples to current SDK versions. ## How Has This Been Tested? - `./tests/smoke-test.sh` passes for every example. - The new tool-loop test passes all 19 checks for Python, TypeScript, Go, and Ruby. - The Rust client was driven through the same scripted conversation with a temporary endpoint resolver (not committed) and passes. - As a negative check, the Ruby client from `main` was run through the new test. It fails 10 of 19 checks, on exactly the bugs listed above. - Go and Ruby were built and run in `golang:1.25` and `ruby:3.4` containers. ## Breaking Changes None. The clients' command lines, output format, and no-key behavior are unchanged. ## Types of changes - [x] Bug fix (non-breaking change which fixes an issue) - [ ] New feature (non-breaking change which adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to change) - [x] Documentation update ## Checklist - [x] I have read the [MCP Documentation](https://modelcontextprotocol.io) - [x] My code follows the repository's style guidelines - [x] New and existing tests pass locally - [x] I have added appropriate error handling - [x] I have added or updated documentation as needed ## Additional context Two pre-existing issues surfaced while testing and are left for a follow-up: - The Rust client (rmcp 3.1.2) negotiates `2025-11-25`. The TypeScript mock server and the Python weather server both reject its calls to array-rooted tools under that revision. Even current rmcp defaults to `2025-11-25`, so the client must request `2026-07-28` explicitly. - The Go SDK's tool-result helper sends content as a list of text blocks rather than a string. The API accepts both, so it is unchanged. AI assistance: the analysis, code changes, test helper, and this description were prepared partially manually, partially with Claude Code and reviewed by me. * Improvements * Address comments
This commit is contained in:
Alex Akimov
GitHub
parent
3844c5b45e
commit
470d1ba328
1 changed files with 695 additions and 140 deletions
|
|
@ -17,10 +17,13 @@ import (
|
|||
"github.com/modelcontextprotocol/go-sdk/mcp"
|
||||
)
|
||||
|
||||
// A string literal rather than an anthropic.Model constant: the pinned SDK
|
||||
// version predates this model and has no constant for it.
|
||||
var model anthropic.Model = "claude-sonnet-5"
|
||||
|
||||
// Sonnet 5 thinks adaptively unless told otherwise, and max_tokens caps thinking
|
||||
// plus the reply, so leave room for both.
|
||||
const maxTokens = 10000
|
||||
const maxToolTurns = 10
|
||||
|
||||
type MCPClient struct {
|
||||
anthropic *anthropic.Client
|
||||
session *mcp.ClientSession
|
||||
|
|
@ -166,98 +169,113 @@ func (c *MCPClient) ProcessQuery(ctx context.Context, query string) (string, err
|
|||
anthropic.NewUserMessage(anthropic.NewTextBlock(query)),
|
||||
}
|
||||
|
||||
var finalText []string
|
||||
|
||||
// Initial Claude API call with tools
|
||||
response, err := c.anthropic.Messages.New(ctx, anthropic.MessageNewParams{
|
||||
Model: model,
|
||||
MaxTokens: 1024,
|
||||
Messages: messages,
|
||||
Tools: c.tools,
|
||||
})
|
||||
response, err := c.createMessage(ctx, messages)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("anthropic API request failed: %w", err)
|
||||
return "", err
|
||||
}
|
||||
|
||||
var toolUseBlocks []anthropic.ToolUseBlock
|
||||
var finalText []string
|
||||
// Keep calling tools until Claude answers without one, up to a cap.
|
||||
for turn := 0; turn < maxToolTurns; turn++ {
|
||||
var toolUseBlocks []anthropic.ToolUseBlock
|
||||
for _, block := range response.Content {
|
||||
switch b := block.AsAny().(type) {
|
||||
case anthropic.TextBlock:
|
||||
finalText = append(finalText, b.Text)
|
||||
case anthropic.ToolUseBlock:
|
||||
toolUseBlocks = append(toolUseBlocks, b)
|
||||
}
|
||||
}
|
||||
|
||||
if len(toolUseBlocks) == 0 {
|
||||
return strings.Join(finalText, "\n"), nil
|
||||
}
|
||||
|
||||
// Execute every tool call in this response and collect the results
|
||||
var anthropicToolResults []anthropic.ContentBlockParamUnion
|
||||
for _, toolUseBlock := range toolUseBlocks {
|
||||
// Add information about the tool call to final text
|
||||
finalText = append(finalText, fmt.Sprintf("[Calling tool %s with args %s]", toolUseBlock.Name, string(toolUseBlock.Input)))
|
||||
|
||||
// Call the MCP server tool
|
||||
mcpToolResult, err := c.session.CallTool(ctx, &mcp.CallToolParams{
|
||||
Name: toolUseBlock.Name,
|
||||
Arguments: toolUseBlock.Input,
|
||||
})
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("tool call %s failed: %w", toolUseBlock.Name, err)
|
||||
}
|
||||
|
||||
if err := c.validateToolOutput(toolUseBlock.Name, mcpToolResult); err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// StructuredContent is data the application can use directly.
|
||||
if items, ok := mcpToolResult.StructuredContent.([]any); ok {
|
||||
finalText = append(finalText, fmt.Sprintf("[%s returned %d items]", toolUseBlock.Name, len(items)))
|
||||
}
|
||||
|
||||
// Content is a list of block types; forward only the text ones.
|
||||
var texts []string
|
||||
for _, block := range mcpToolResult.Content {
|
||||
if text, ok := block.(*mcp.TextContent); ok {
|
||||
texts = append(texts, text.Text)
|
||||
}
|
||||
}
|
||||
|
||||
anthropicToolResults = append(anthropicToolResults, anthropic.NewToolResultBlock(
|
||||
toolUseBlock.ID,
|
||||
strings.Join(texts, "\n"),
|
||||
mcpToolResult.IsError,
|
||||
))
|
||||
}
|
||||
|
||||
// Append the assistant's response and all tool results, in one user
|
||||
// message, to the history. Every tool_use needs a matching tool_result.
|
||||
messages = append(messages, response.ToParam())
|
||||
messages = append(messages, anthropic.NewUserMessage(anthropicToolResults...))
|
||||
|
||||
response, err = c.createMessage(ctx, messages)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
|
||||
// The turn cap was hit. Keep the last response's text. If it asked for
|
||||
// more tools, say they were not run.
|
||||
wantsTools := false
|
||||
for _, block := range response.Content {
|
||||
switch b := block.AsAny().(type) {
|
||||
case anthropic.TextBlock:
|
||||
finalText = append(finalText, b.Text)
|
||||
case anthropic.ToolUseBlock:
|
||||
toolUseBlocks = append(toolUseBlocks, b)
|
||||
wantsTools = true
|
||||
}
|
||||
}
|
||||
|
||||
if len(toolUseBlocks) == 0 {
|
||||
return strings.Join(finalText, "\n"), nil
|
||||
}
|
||||
|
||||
// Append assistant's response to message history
|
||||
messages = append(messages, response.ToParam())
|
||||
|
||||
// Execute each tool call and collect responses
|
||||
var anthropicToolResults []anthropic.ContentBlockParamUnion
|
||||
for _, toolUseBlock := range toolUseBlocks {
|
||||
// Add information about the tool call to final text
|
||||
finalText = append(finalText, fmt.Sprintf("[Calling tool %s with args %s]", toolUseBlock.Name, string(toolUseBlock.Input)))
|
||||
|
||||
// Call the MCP server tool
|
||||
mcpToolResult, err := c.session.CallTool(ctx, &mcp.CallToolParams{
|
||||
Name: toolUseBlock.Name,
|
||||
Arguments: toolUseBlock.Input,
|
||||
})
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("tool call %s failed: %w", toolUseBlock.Name, err)
|
||||
}
|
||||
|
||||
if err := c.validateToolOutput(toolUseBlock.Name, mcpToolResult); err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// StructuredContent is data the application can use directly.
|
||||
if items, ok := mcpToolResult.StructuredContent.([]any); ok {
|
||||
finalText = append(finalText, fmt.Sprintf("[%s returned %d items]", toolUseBlock.Name, len(items)))
|
||||
}
|
||||
|
||||
// Content is a list of block types; forward only the text ones.
|
||||
var texts []string
|
||||
for _, block := range mcpToolResult.Content {
|
||||
if text, ok := block.(*mcp.TextContent); ok {
|
||||
texts = append(texts, text.Text)
|
||||
}
|
||||
}
|
||||
|
||||
anthropicToolResults = append(anthropicToolResults, anthropic.NewToolResultBlock(
|
||||
toolUseBlock.ID,
|
||||
strings.Join(texts, "\n"),
|
||||
mcpToolResult.IsError,
|
||||
))
|
||||
}
|
||||
|
||||
// Append tool responses to message history
|
||||
messages = append(messages, anthropic.NewUserMessage(anthropicToolResults...))
|
||||
|
||||
// Make another API call with tool results
|
||||
response, err = c.anthropic.Messages.New(ctx, anthropic.MessageNewParams{
|
||||
Model: model,
|
||||
MaxTokens: 1024,
|
||||
Messages: messages,
|
||||
})
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("anthropic API request with tool results failed: %w", err)
|
||||
}
|
||||
|
||||
// Collect text from final response
|
||||
for _, block := range response.Content {
|
||||
switch b := block.AsAny().(type) {
|
||||
case anthropic.TextBlock:
|
||||
finalText = append(finalText, b.Text)
|
||||
}
|
||||
if wantsTools {
|
||||
finalText = append(finalText, fmt.Sprintf("[Stopped after %d tool-use turns]", maxToolTurns))
|
||||
}
|
||||
|
||||
return strings.Join(finalText, "\n"), nil
|
||||
}
|
||||
|
||||
// createMessage calls Claude with the current history. Tools are passed on
|
||||
// every call so Claude can keep calling them across turns.
|
||||
func (c *MCPClient) createMessage(ctx context.Context, messages []anthropic.MessageParam) (*anthropic.Message, error) {
|
||||
response, err := c.anthropic.Messages.New(ctx, anthropic.MessageNewParams{
|
||||
Model: model,
|
||||
MaxTokens: maxTokens,
|
||||
Messages: messages,
|
||||
Tools: c.tools,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("anthropic API request failed: %w", err)
|
||||
}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *MCPClient) ChatLoop(ctx context.Context) error {
|
||||
fmt.Println("\nMCP Client Started!")
|
||||
fmt.Println("Type your queries or 'quit' to exit.")
|
||||
|
|
|
|||
Loading…
Reference in a new issue