feat(node): Add LangChain v1 support (getsentry#18306)

This PR adds support for LangChain v1.

## Changes

- LangChain v1 Response Metadata Extraction

- Updated response attribute extraction to support LangChain v1's
different data structure:

- Instrument ConfigurableModel from `chat_models/universal.cjs`

Quick context: 

The `initChatModel` unified API (introduced in LangChain v1) was not
being instrumented in CJS applications. This happened because:

1. `initChatModel` uses dynamic `import()` to load providers (even in
CJS mode)
2. OpenTelemetry's CJS instrumentation only hooks `require()`, not
dynamic `import()`
3. Provider packages like `@langchain/openai` were never being patched
when loaded via `initChatModel`

**Solution**: Added instrumentation for the main `langchain` package.
When `langchain/dist/chat_models/universal.cjs` is loaded, we patch the
`ConfigurableModel` prototype. Since `initChatModel` returns a
`ConfigurableModel` instance, it inherits the patched methods regardless
of how the provider is loaded.

This fix ensures `initChatModel` works in CJS applications without
requiring users to manually import provider packages.

- Add tests for node integrations tests testing v1 changes
- All existing tests continue to pass
- New v1 test suite validates:
    - Basic chat model spans with and without PII
    - Tool call instrumentation
    - Message truncation behavior
    - Timing issues with pre-imported clients
    - `initChatModel` API with OpenAI (now working in both ESM and CJS)

Closes https://linear.app/getsentry/issue/JS-1071/support-langchain-v1

dev-packages/node-integration-tests/suites/tracing/langchain/v1/instrument-with-pii.mjs

@@ -0,0 +1,17 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  sendDefaultPii: true,
+  transport: loggingTransport,
+  beforeSendTransaction: event => {
+    // Filter out mock express server transactions
+    if (event.transaction.includes('/v1/messages') || event.transaction.includes('/v1/chat/completions')) {
+      return null;
+    }
+    return event;
+  },
+});

dev-packages/node-integration-tests/suites/tracing/langchain/v1/instrument.mjs

@@ -0,0 +1,17 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  sendDefaultPii: false,
+  transport: loggingTransport,
+  beforeSendTransaction: event => {
+    // Filter out mock express server transactions
+    if (event.transaction.includes('/v1/messages') || event.transaction.includes('/v1/chat/completions')) {
+      return null;
+    }
+    return event;
+  },
+});

dev-packages/node-integration-tests/suites/tracing/langchain/v1/scenario-init-chat-model.mjs

@@ -0,0 +1,110 @@
+import * as Sentry from '@sentry/node';
+import express from 'express';
+import { initChatModel } from 'langchain';
+
+function startMockOpenAIServer() {
+  const app = express();
+  app.use(express.json());
+
+  app.post('/v1/chat/completions', (req, res) => {
+    const model = req.body.model;
+
+    if (model === 'error-model') {
+      res.status(404).json({
+        error: {
+          message: 'Model not found',
+          type: 'invalid_request_error',
+          param: null,
+          code: 'model_not_found',
+        },
+      });
+      return;
+    }
+
+    // Simulate OpenAI response
+    res.json({
+      id: 'chatcmpl-init-test-123',
+      object: 'chat.completion',
+      created: 1677652288,
+      model: model,
+      system_fingerprint: 'fp_44709d6fcb',
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: 'assistant',
+            content: 'Hello from initChatModel!',
+          },
+          finish_reason: 'stop',
+        },
+      ],
+      usage: {
+        prompt_tokens: 8,
+        completion_tokens: 12,
+        total_tokens: 20,
+      },
+    });
+  });
+
+  return new Promise(resolve => {
+    const server = app.listen(0, () => {
+      resolve(server);
+    });
+  });
+}
+
+async function run() {
+  const server = await startMockOpenAIServer();
+  const baseUrl = `http://localhost:${server.address().port}/v1`;
+
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    // Set OpenAI API key in environment
+    process.env.OPENAI_API_KEY = 'mock-api-key';
+
+    // Test 1: Initialize chat model using unified API with model string
+    const model1 = await initChatModel('gpt-4o', {
+      temperature: 0.7,
+      maxTokens: 100,
+      modelProvider: 'openai',
+      configurableFields: ['model'],
+      configuration: {
+        baseURL: baseUrl,
+      },
+    });
+
+    await model1.invoke('Tell me about LangChain');
+
+    // Test 2: Initialize with different model
+    const model2 = await initChatModel('gpt-3.5-turbo', {
+      temperature: 0.5,
+      modelProvider: 'openai',
+      configuration: {
+        baseURL: baseUrl,
+      },
+    });
+
+    await model2.invoke([
+      { role: 'system', content: 'You are a helpful assistant' },
+      { role: 'user', content: 'What is AI?' },
+    ]);
+
+    // Test 3: Error handling
+    try {
+      const errorModel = await initChatModel('error-model', {
+        modelProvider: 'openai',
+        configuration: {
+          baseURL: baseUrl,
+        },
+      });
+      await errorModel.invoke('This will fail');
+    } catch {
+      // Expected error
+    }
+  });
+
+  await Sentry.flush(2000);
+
+  server.close();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/langchain/v1/scenario-message-truncation.mjs

@@ -0,0 +1,72 @@
+import { ChatAnthropic } from '@langchain/anthropic';
+import * as Sentry from '@sentry/node';
+import express from 'express';
+
+function startMockAnthropicServer() {
+  const app = express();
+  app.use(express.json());
+
+  app.post('/v1/messages', (req, res) => {
+    const model = req.body.model;
+
+    res.json({
+      id: 'msg_truncation_test',
+      type: 'message',
+      role: 'assistant',
+      content: [
+        {
+          type: 'text',
+          text: 'Response to truncated messages',
+        },
+      ],
+      model: model,
+      stop_reason: 'end_turn',
+      stop_sequence: null,
+      usage: {
+        input_tokens: 10,
+        output_tokens: 15,
+      },
+    });
+  });
+
+  return new Promise(resolve => {
+    const server = app.listen(0, () => {
+      resolve(server);
+    });
+  });
+}
+
+async function run() {
+  const server = await startMockAnthropicServer();
+  const baseUrl = `http://localhost:${server.address().port}`;
+
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    const model = new ChatAnthropic({
+      model: 'claude-3-5-sonnet-20241022',
+      apiKey: 'mock-api-key',
+      clientOptions: {
+        baseURL: baseUrl,
+      },
+    });
+
+    const largeContent1 = 'A'.repeat(15000); // ~15KB
+    const largeContent2 = 'B'.repeat(15000); // ~15KB
+    const largeContent3 = 'C'.repeat(25000); // ~25KB (will be truncated)
+
+    // Create one very large string that gets truncated to only include Cs
+    await model.invoke(largeContent3 + largeContent2);
+
+    // Create an array of messages that gets truncated to only include the last message (result should again contain only Cs)
+    await model.invoke([
+      { role: 'system', content: largeContent1 },
+      { role: 'user', content: largeContent2 },
+      { role: 'user', content: largeContent3 },
+    ]);
+  });
+
+  await Sentry.flush(2000);
+
+  server.close();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/langchain/v1/scenario-openai-before-langchain.mjs

@@ -0,0 +1,95 @@
+import * as Sentry from '@sentry/node';
+import express from 'express';
+
+function startMockAnthropicServer() {
+  const app = express();
+  app.use(express.json());
+
+  app.post('/v1/messages', (req, res) => {
+    res.json({
+      id: 'msg_test123',
+      type: 'message',
+      role: 'assistant',
+      content: [
+        {
+          type: 'text',
+          text: 'Mock response from Anthropic!',
+        },
+      ],
+      model: req.body.model,
+      stop_reason: 'end_turn',
+      stop_sequence: null,
+      usage: {
+        input_tokens: 10,
+        output_tokens: 15,
+      },
+    });
+  });
+
+  return new Promise(resolve => {
+    const server = app.listen(0, () => {
+      resolve(server);
+    });
+  });
+}
+
+async function run() {
+  const server = await startMockAnthropicServer();
+  const baseURL = `http://localhost:${server.address().port}`;
+
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    // EDGE CASE: Import and instantiate Anthropic client BEFORE LangChain is imported
+    // This simulates the timing issue where a user creates an Anthropic client in one file
+    // before importing LangChain in another file
+    const { default: Anthropic } = await import('@anthropic-ai/sdk');
+    const anthropicClient = new Anthropic({
+      apiKey: 'mock-api-key',
+      baseURL,
+    });
+
+    // Use the Anthropic client directly - this will be instrumented by the Anthropic integration
+    await anthropicClient.messages.create({
+      model: 'claude-3-5-sonnet-20241022',
+      messages: [{ role: 'user', content: 'Direct Anthropic call' }],
+      temperature: 0.7,
+      max_tokens: 100,
+    });
+
+    // NOW import LangChain - at this point it will mark Anthropic to be skipped
+    // But the client created above is already instrumented
+    const { ChatAnthropic } = await import('@langchain/anthropic');
+
+    // Create a LangChain model - this uses Anthropic under the hood
+    const langchainModel = new ChatAnthropic({
+      model: 'claude-3-5-sonnet-20241022',
+      temperature: 0.7,
+      maxTokens: 100,
+      apiKey: 'mock-api-key',
+      clientOptions: {
+        baseURL,
+      },
+    });
+
+    // Use LangChain - this will be instrumented by LangChain integration
+    await langchainModel.invoke('LangChain Anthropic call');
+
+    // Create ANOTHER Anthropic client after LangChain was imported
+    // This one should NOT be instrumented (skip mechanism works correctly)
+    const anthropicClient2 = new Anthropic({
+      apiKey: 'mock-api-key',
+      baseURL,
+    });
+
+    await anthropicClient2.messages.create({
+      model: 'claude-3-5-sonnet-20241022',
+      messages: [{ role: 'user', content: 'Second direct Anthropic call' }],
+      temperature: 0.7,
+      max_tokens: 100,
+    });
+  });
+
+  await Sentry.flush(2000);
+  server.close();
+}
+
+run();