cd /news/ai-agents/notes-from-a-2-am-on-call-why-our-st… · home › topics › ai-agents › article
[ARTICLE · art-170897] src=dev.to ↗ pub= topic=ai-agents verified=true sentiment=↓ negative

Notes from a 2 AM On-Call: Why Our Stitch MCP Server Died Silently on Tool Timeouts

A developer traced a silent 2:14 AM failure of the stitch-skills MCP server to an implicit 30-second read timeout in the @modelcontextprotocol/sdk stdio transport (0.5.x), which closed the pipe mid-execution and triggered an unhandled SIGPIPE that Node.js handled with a clean exit(0). Because the transport exposes no timeout configuration, the fix wraps tool handlers in a Promise.race with a 25-second skill timeout and registers a SIGPIPE handler that exits non-zero for monitoring.

by read3 min views11 publishedNov 16, 2026

At 2:14 AM PST, our Stitch MCP server process (stitch-skills) running against Claude Code agents went dark. No crash logs. No stderr output. Just a silent exit 0 and a socket EOF on the client side.

The raw symptom:

[claude-code] Error: MCP server connection lost (code: 0)
[stitch-skills] (no output, clean exit)
[docker stats] stitch-skills container: 137 (OOMKilled? No.)

No OOM. No segfault. Just a graceful suicide.

Every MCP tutorial tells you to wrap tool handlers in try-catch. We did:

// What the docs recommend
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  try {
    const result = await executeSkill(request.params.name, request.params.arguments);
    return { content: [{ type: "text", text: JSON.stringify(result) }] };
  } catch (error) {
    return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
  }
});

This handles synchronous exceptions. It does not handle the case where executeSkill() spawns a long-running subprocess (like git clone or npm install in a skill) that hangs indefinitely, and the MCP JSON-RPC transport times out before the Promise settles.

What actually happened: Claude Code sent a tools/call request to execute the git_clone_skill from stitch-skills. The skill spawned git clone https://massive-monorepo.git (4.2 GB). After 30 seconds, the stdio transport's implicit read timeout fired, but our handler was still await-ing the git process. The transport layer closed the stdio pipe, the process received SIGPIPE, and Node.js default SIGPIPE handler called process.exit(0).

No exception. No stderr. Silent death.

The @modelcontextprotocol/sdk stdio transport has an implicit 30s read timeout, but does not expose a timeout config option in the current stable release (0.5.x). When a tool handler exceeds this, the transport closes, but unhandled SIGPIPE kills the process.

The 3-line fix:

// server.ts - Add at the top of your Stitch MCP server entrypoint
process.on('SIGPIPE', () => {
  console.error('[SIGPIPE] Transport closed mid-execution, graceful shutdown');
  process.exit(1); // Non-zero for monitoring
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const SKILL_TIMEOUT_MS = 25000; // Under transport's 30s limit
  try {
    const result = await Promise.race([
      executeSkill(request.params.name, request.params.arguments),
      new Promise((_, reject) => 
        setTimeout(() => reject(new Error('Skill timeout')), SKILL_TIMEOUT_MS)
      )
    ]);
    return { content: [{ type: "text", text: JSON.stringify(result) }] };
  } catch (error) {
    console.error(`[tool:${request.params.name}] ${error.message}`);
    return { 
      content: [{ type: "text", text: `Execution failed: ${error.message}` }], 
      isError: true 
    };
  }
});

Key changes:

Promise.race() enforces a 25s skill timeout, guaranteeing handler completion before transport timeout. When integrating stitch-skills with Claude Code, add monitoring to your claude_desktop_config.json:

{
  "mcpServers": {
    "stitch": {
      "command": "node",
      "args": ["/path/to/stitch-skills/dist/server.js"],
      "env": {
        "NODE_OPTIONS": "--max-old-space-size=512",
        "SKILL_TIMEOUT_MS": "25000"
      }
    }
  }
}

For production deployments routing through a relay gateway (e.g., when benchmarking multi-model fallback through B-Lost's relay at https://b-lost.com/v1), add health checks:

// health-check.ts
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';

const transport = new StdioClientTransport({
  command: 'node',
  args: ['./dist/server.js']
});

const client = new Client({ name: 'health-check', version: '1.0.0' }, { capabilities: {} });

await client.connect(transport);
const tools = await client.listTools();
console.log(`Stitch MCP healthy: ${tools.tools.length} skills registered`);
await client.close();

Never trust MCP tool handlers to complete within transport timeouts. Every async skill execution must be wrapped in Promise.race() with a timeout 5-10s shorter than your transport's read deadline. The stdio transport's 30s limit is implicit and non-configurable in SDK 0.5.x.

For skills executing git operations, subprocess spawns, or HTTP calls to external APIs, this is non-negotiable. The alternative is silent process death and confused on-call engineers at 2 AM.

When testing stitch-skills against Claude Code or Cursor, monitor for exit 0 events without preceding error logs—that's your canary for unhandled transport closure.

── more in #ai-agents 4 stories · sorted by recency
── more on @claude code 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/notes-from-a-2-am-on…] indexed:0 read:3min 2026-11-16 · —