Fix TypeScript Compilation OOM (JavaScript heap out of memory) When Using @modelcontextprotocol/sdk in CI/CD, Turborepo, and Containerized Builds

Version 1.22.0 is the last known version where TypeScript compilation memory is manageable. Versions >=1.23.0 introduced Zod v4 dual-support types that increased type complexity, with users reporting memory regression persisting through 1.25.1+. Downgrading to 1.22.0 avoids the newer type definitions while keeping type checking functional.

1. Step 1: Install SDK v1.22.0: `npm install @modelcontextprotocol/sdk@1.22.0`
2. Step 2: Verify zod dependency is ^3.23.8 (Zod v3 only): `npm view @modelcontextprotocol/sdk@1.22.0 dependencies.zod`
3. Step 3: Rebuild and verify memory usage

npm install @modelcontextprotocol/sdk@1.22.0

npm view @modelcontextprotocol/sdk@1.22.0 dependencies.zod

NODE_OPTIONS="--max-old-space-size=1536" tsc -p tsconfig.build.json

// Verified: v1.22.0 has zod ^3.23.8 (v3 only, no v4 dual-support)
// Verified: v1.25.1+ has zod ^3.25 || ^4.0 (triggers OOM for some users)
// Latest v1.x as of June 2026: v1.29.0

Ensure only ONE major version of Zod exists in your dependency tree. The OOM is exacerbated when TypeScript must resolve types from both Zod v3 and Zod v4 simultaneously. Use pnpm overrides, npm overrides, or yarn resolutions to force a single Zod version.

1. Step 1: Run `npm why zod` (or `pnpm why zod`) to detect duplicate Zod versions
2. Step 2: Add package.json overrides to pin all Zod dependencies to a single version
3. Step 3: Clear node_modules and lockfile, reinstall, rebuild

npm why zod

rm -rf node_modules package-lock.json && npm install

npm run build

// package.json — npm overrides (npm 8.3+):
{
  "overrides": {
    "zod": "3.25.76"
  }
}

// package.json — pnpm:
{
  "pnpm": {
    "overrides": {
      "zod": "3.25.76"
    }
  }
}

// package.json — yarn:
{
  "resolutions": {
    "zod": "3.25.76"
  }
}

Cast MCP tool callback parameters to `any` instead of using the SDK's generic types. This prevents TypeScript from resolving the deeply nested Zod-derived types entirely, avoiding the memory explosion while keeping type checking enabled for the rest of your project.

1. Step 1: Identify all server.tool() and server.registerTool() calls in your MCP server
2. Step 2: Replace the typed callback signature with `any` cast
3. Step 3: Verify build completes without OOM

npm run build

// Before (triggers OOM):
server.registerTool('search', {
  title: 'Search Articles',
  description: 'Search the knowledge base',
  inputSchema: SearchParamsSchema,
}, async (params: z.infer<typeof SearchParamsSchema>) => {
  // implementation
});

// After (avoids OOM):
server.registerTool('search', {
  title: 'Search Articles',
  description: 'Search the knowledge base',
  inputSchema: SearchParamsSchema as any,
}, async (params: any) => {
  // implementation — lose param type safety but keep rest of project typed
});

Add --noCheck flag to TypeScript compilation to bypass type checking entirely during the build step, reducing memory from 4GB+ to ~512MB. Move type checking to a separate lint step that doesn't block builds.

1. Step 1: Modify your build script in package.json to add --noCheck
2. Step 2: Move type checking to a separate script (e.g., 'typecheck')
3. Step 3: Run only the build step in CI; run typecheck as a non-blocking parallel job

NODE_OPTIONS="--max-old-space-size=1536" tsc -p tsconfig.build.json --noCheck

npm pkg set scripts.typecheck="tsc --noEmit"

{
  "scripts": {
    "build": "NODE_OPTIONS=\"--max-old-space-size=1536\" tsc -p tsconfig.build.json --noCheck",
    "typecheck": "tsc --noEmit"
  }
}