this would work

Author: RulaKhaled

packages/node/src/integrations/tracing/vercelai/index.ts

@@ -1,29 +1,40 @@
-import type { IntegrationFn } from '@sentry/core';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Client, IntegrationFn } from '@sentry/core';
 import { addVercelAiProcessors, defineIntegration } from '@sentry/core';
-import { generateInstrumentOnce } from '@sentry/node-core';
+import { generateInstrumentOnce, type modulesIntegration } from '@sentry/node-core';
 import { INTEGRATION_NAME } from './constants';
 import { SentryVercelAiInstrumentation } from './instrumentation';
 import type { VercelAiOptions } from './types';
 
 export const instrumentVercelAi = generateInstrumentOnce(INTEGRATION_NAME, () => new SentryVercelAiInstrumentation({}));
 
 /**
- * Determines if the 'ai' package is installed and available.
- *
- * Uses require.resolve() to check for package availability without loading it.
- * This approach avoids race conditions that can occur with filesystem-based
- * detection during initialization in serverless environments (Lambda/Vercel).
- *
- * @returns true if the 'ai' package can be resolved, false otherwise
+ * Determines if the integration should be forced based on environment and package availability.
+ * Returns true if the 'ai' package is available.
  */
-function shouldForceIntegration(): boolean {
-  try {
-    const moduleName = 'ai';
-    require.resolve(moduleName);
-    return true;
-  } catch {
+function shouldForceIntegration(client: Client): boolean {
+  const modules = client.getIntegrationByName<ReturnType<typeof modulesIntegration>>('Modules');
+
+  if (!modules?.getModules) {
     return false;
   }
+
+  let moduleList = modules.getModules();
+
+  // Workaround for race condition in serverless environments:
+  // If module list is empty, the filesystem may not have been ready during initialization.
+  // Perform a filesystem check to warm it up, then retry.
+  if (Object.keys(moduleList).length === 0) {
+    try {
+      existsSync(join(process.cwd(), 'package.json'));
+      moduleList = modules.getModules();
+    } catch {
+      return false;
+    }
+  }
+
+  return !!moduleList?.ai;
 }
 
 const _vercelAIIntegration = ((options: VercelAiOptions = {}) => {
@@ -36,14 +47,13 @@ const _vercelAIIntegration = ((options: VercelAiOptions = {}) => {
       instrumentation = instrumentVercelAi();
     },
     afterAllSetup(client) {
-      // Auto-detect if we should force the integration when the 'ai' package is available
-      // Uses require.resolve() for reliable detection in all environments
-      const shouldForce = options.force ?? shouldForceIntegration();
+      // Auto-detect if we should force the integration when running with 'ai' package available
+      // Note that this can only be detected if the 'Modules' integration is available, and running in CJS mode
+      const shouldForce = options.force ?? shouldForceIntegration(client);
 
       if (shouldForce) {
         addVercelAiProcessors(client);
       } else {
-        // Lazy registration - only registers when 'ai' package is actually imported
         instrumentation?.callWhenPatched(() => addVercelAiProcessors(client));
       }
     },