Claude Code Sonnet 4.5 randomly crash with sequentialthinking (MCP)

[suraneti]

Describe the bug
When an Agent tries to use MCP, it crashes randomly sometimes.

To Reproduce
Steps to reproduce the behavior:

1. Claude Code Sonnet 4.5
2. Trigger sequentialthinking (MCP)

Expected behavior
It should be working the same as sonnet 4

Logs

sequential-thinking - sequentialthinking (MCP)(thought: XXX)

  Error: {
       "error": "Invalid thoughtNumber: must be a number",
       "status": "failed"
     }

[JCJinvesting]

Workaround: Type Coercion Wrapper for Claude Sonnet 4.5

I've created a working solution for the "Invalid thoughtNumber: must be a number" errors with Claude Sonnet 4.5.

Root Cause: Claude Sonnet 4.5 sometimes sends string values ("1") instead of numeric values (1) for integer parameters, which the server's strict validation rejects.

Solution: A Node.js wrapper that intercepts and coerces types before they reach the MCP server.

Implementation:

Create sequential-thinking-wrapper.js:

#!/usr/bin/env node

/**
 * Sequential Thinking Wrapper - Handles type coercion for Claude Sonnet 4.5
 * 
 * Problem: Claude sometimes sends string numbers ("1") instead of integers (1)
 * Solution: Intercept and coerce types before passing to the MCP server
 */

const { spawn } = require('child_process');
const readline = require('readline');

console.error('[Sequential-Thinking Wrapper] Starting with type coercion...');

// Start the actual sequential-thinking server
const serverProcess = spawn('npx', ['-y', '@modelcontextprotocol/server-sequential-thinking@latest'], {
  stdio: ['pipe', 'pipe', 'inherit'],
  shell: true
});

// Create readline interfaces for line-by-line processing
const inputReader = readline.createInterface({
  input: process.stdin,
  crlfDelay: Infinity
});

const outputReader = readline.createInterface({
  input: serverProcess.stdout,
  crlfDelay: Infinity
});

/**
 * Coerce string numbers to actual numbers in the data
 */
function coerceTypes(data) {
  try {
    const parsed = JSON.parse(data);
    
    // Check if this is a tool call with parameters
    if (parsed.params && parsed.params.arguments) {
      const args = parsed.params.arguments;
      
      // Coerce numeric parameters
      const numericFields = [
        'thoughtNumber',
        'totalThoughts',
        'revisesThought',
        'branchFromThought'
      ];
      
      numericFields.forEach(field => {
        if (args[field] !== undefined) {
          // Convert string numbers to actual numbers
          if (typeof args[field] === 'string' && !isNaN(args[field])) {
            args[field] = parseInt(args[field], 10);
            console.error(`[Wrapper] Coerced ${field}: "${args[field]}" -> ${args[field]}`);
          }
        }
      });
      
      // Coerce boolean parameters
      const booleanFields = [
        'nextThoughtNeeded',
        'isRevision',
        'needsMoreThoughts'
      ];
      
      booleanFields.forEach(field => {
        if (args[field] !== undefined) {
          if (typeof args[field] === 'string') {
            args[field] = args[field].toLowerCase() === 'true';
            console.error(`[Wrapper] Coerced ${field}: "${args[field]}" -> ${args[field]}`);
          }
        }
      });
    }
    
    return JSON.stringify(parsed);
  } catch (e) {
    // If not JSON or parsing fails, return as-is
    return data;
  }
}

// Forward stdin to server with type coercion
inputReader.on('line', (line) => {
  const coerced = coerceTypes(line);
  serverProcess.stdin.write(coerced + '\n');
});

// Forward server output to stdout
outputReader.on('line', (line) => {
  process.stdout.write(line + '\n');
});

// Handle process termination
process.stdin.on('end', () => {
  serverProcess.stdin.end();
});

serverProcess.on('exit', (code, signal) => {
  console.error(`[Wrapper] Server exited with code ${code}, signal ${signal}`);
  process.exit(code || 0);
});

serverProcess.on('error', (error) => {
  console.error(`[Wrapper] Server error:`, error);
  process.exit(1);
});

// Forward signals
process.on('SIGTERM', () => serverProcess.kill('SIGTERM'));
process.on('SIGINT', () => serverProcess.kill('SIGINT'));

MCP Configuration:

Update your mcp_config.json:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "node",
      "args": ["path/to/sequential-thinking-wrapper.js"],
      "env": {
        "DISABLE_THOUGHT_LOGGING": "false"
      },
      "disabled": false
    }
  }
}

Results:

✅ Eliminates "Invalid thoughtNumber: must be a number" errors
✅ Works reliably with Claude Sonnet 4.5
✅ Logs type coercions for debugging
✅ No changes needed to the MCP server itself

This is a temporary workaround until the server implements proper type coercion or better parameter validation. Hope this helps others experiencing the same issue!