Fix the tool-use loop in the Go, Rust, and Ruby clients and add a tool-loop smoke test (#200)

* 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

mcp-client-ruby/client.rb

@@ -7,6 +7,10 @@ require "mcp"
 
 class MCPClient
   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.
+  MAX_TOKENS = 10000
+  MAX_TOOL_TURNS = 10
 
   def initialize
     @mcp_client = nil
@@ -49,6 +53,7 @@ class MCPClient
 
     loop do
       print "\nQuery: "
+      $stdout.flush # a pipe is not line-buffered, so show the prompt before waiting
       line = $stdin.gets
       break if line.nil?
 
@@ -78,40 +83,40 @@ class MCPClient
       { name: tool.name, description: tool.description, input_schema: tool.input_schema }
     end
 
-    # Initial Claude API call.
-    response = chat(messages, tools: available_tools)
+    final_text = []
 
-    # Process response and handle tool calls.
-    if response.content.any?(Anthropic::Models::ToolUseBlock)
-      assistant_content = response.content.filter_map do |content_block|
-        case content_block
+    # Initial Claude API call with tools.
+    response = chat(messages, available_tools)
+
+    # Keep calling tools until Claude answers without one, up to a cap.
+    MAX_TOOL_TURNS.times do
+      tool_uses = []
+      response.content.each do |block|
+        case block
         when Anthropic::Models::TextBlock
-          { type: "text", text: content_block.text }
+          final_text << block.text
         when Anthropic::Models::ToolUseBlock
-          { type: "tool_use", id: content_block.id, name: content_block.name, input: content_block.input }
+          tool_uses << block
         end
       end
-      messages << { role: "assistant", content: assistant_content }
-    end
 
-    response.content.each_with_object([]) do |content, response_parts|
-      case content
-      when Anthropic::Models::TextBlock
-        response_parts << content.text
-      when Anthropic::Models::ToolUseBlock
-        # Execute tool call via MCP.
-        result = @mcp_client.call_tool(name: content.name, arguments: content.input)
-        response_parts << "[Calling tool #{content.name} with args #{content.input.to_json}]"
+      return final_text.join("\n") if tool_uses.empty?
+
+      # Execute every tool call in this response and collect the results.
+      tool_results = tool_uses.map do |tool_use|
+        result = @mcp_client.call_tool(name: tool_use.name, arguments: tool_use.input)
+        final_text << "[Calling tool #{tool_use.name} with args #{tool_use.input.to_json}]"
 
         # structured_content is data the application can use directly; when a
         # tool returns an array, count its items rather than re-reading prose.
+        is_error = result.dig("result", "isError") == true
         structured = result.dig("result", "structuredContent")
-        unless result.dig("result", "isError")
-          @output_schemas[content.name]&.validate_result(structured)
-          response_parts << "[#{content.name} returned #{structured.length} items]" if structured.is_a?(Array)
+        unless is_error
+          @output_schemas[tool_use.name]&.validate_result(structured)
+          final_text << "[#{tool_use.name} returned #{structured.length} items]" if structured.is_a?(Array)
         end
 
-        # content is what the model reads.
+        # content is a list of block types; forward only the text ones.
         tool_result_content = result.dig("result", "content")
         result_text = if tool_result_content.is_a?(Array)
           tool_result_content.filter_map { |content_item| content_item["text"] }.join("\n")
@@ -119,30 +124,54 @@ class MCPClient
           tool_result_content.to_s
         end
 
-        messages << {
-          role: "user",
-          content: [{
-            type: "tool_result",
-            tool_use_id: content.id,
-            content: result_text
-          }]
-        }
-
-        # Get next response from Claude.
-        response = chat(messages)
-
-        response.content.each do |content_block|
-          response_parts << content_block.text if content_block.is_a?(Anthropic::Models::TextBlock)
-        end
+        { type: "tool_result", tool_use_id: tool_use.id, content: result_text, is_error: is_error }
       end
-    end.join("\n")
+
+      # 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 << { role: "assistant", content: assistant_content(response) }
+      messages << { role: "user", content: tool_results }
+
+      response = chat(messages, available_tools)
+    end
+
+    # The turn cap was hit. Keep the last response's text. If it asked for
+    # more tools, say they were not run.
+    response.content.each do |block|
+      final_text << block.text if block.is_a?(Anthropic::Models::TextBlock)
+    end
+    if response.content.any?(Anthropic::Models::ToolUseBlock)
+      final_text << "[Stopped after #{MAX_TOOL_TURNS} tool-use turns]"
+    end
+    final_text.join("\n")
   end
 
-  def chat(messages, tools: nil)
-    params = { model: ANTHROPIC_MODEL, max_tokens: 1000, messages: messages }
-    params[:tools] = tools if tools
+  # Convert a response's content blocks back into request parameters. Thinking
+  # blocks must go back unchanged, signature included, or the API rejects the
+  # follow-up request.
+  def assistant_content(response)
+    response.content.filter_map do |block|
+      case block
+      when Anthropic::Models::TextBlock
+        { type: "text", text: block.text }
+      when Anthropic::Models::ToolUseBlock
+        { type: "tool_use", id: block.id, name: block.name, input: block.input }
+      when Anthropic::Models::ThinkingBlock
+        { type: "thinking", thinking: block.thinking, signature: block.signature }
+      when Anthropic::Models::RedactedThinkingBlock
+        { type: "redacted_thinking", data: block.data }
+      end
+    end
+  end
 
-    anthropic_client.messages.create(**params)
+  # Tools are passed on every call so Claude can keep calling them across turns.
+  def chat(messages, tools)
+    anthropic_client.messages.create(
+      model: ANTHROPIC_MODEL,
+      max_tokens: MAX_TOKENS,
+      messages: messages,
+      tools: tools
+    )
   end
 
   def anthropic_client