newrelic 13.10.0 → 13.12.0

package/NEWS.md

@@ -1,3 +1,61 @@
+### v13.12.0 (2026-02-02)
+
+#### Features
+
+* Added instrumentation support for `@langchain/langgraph` ([#3645](https://github.com/newrelic/node-newrelic/pull/3645)) ([f339675](https://github.com/newrelic/node-newrelic/commit/f3396754fb182a3f0af09488a8abb1981b6f3e3f))
+* Added `timestamp` to `LlmChatCompletionSummary` messages
+    * Added `timestamp` to AWS Bedrock `LlmChatCompletionSummary` ([#3702](https://github.com/newrelic/node-newrelic/pull/3702)) ([430d1dd](https://github.com/newrelic/node-newrelic/commit/430d1dd5ef847203045486a054142df3a02c7c1c))
+    * Added `timestamp` to Google Gen AI `LlmChatCompletionSummary` ([#3690](https://github.com/newrelic/node-newrelic/pull/3690)) ([7748e26](https://github.com/newrelic/node-newrelic/commit/7748e26aceb7b050b13dc686c852513026f043ac))
+    * Added `timestamp` to LangChain `LlmChatCompletionSummary` ([#3701](https://github.com/newrelic/node-newrelic/pull/3701)) ([7472118](https://github.com/newrelic/node-newrelic/commit/747211814396e4bf52dc63d249c0ec045b35457a))
+* Added compact mode for span links ([#3681](https://github.com/newrelic/node-newrelic/pull/3681)) ([6ff6961](https://github.com/newrelic/node-newrelic/commit/6ff6961e6b46feb14638da97a95d0891a0d88645))
+
+#### Bug fixes
+
+* Updated langchain tool instrumentation to properly redefine the segment name on every call ([#3691](https://github.com/newrelic/node-newrelic/pull/3691)) ([4df6068](https://github.com/newrelic/node-newrelic/commit/4df6068d23b5da276486bd3d3f0c3af4b748c4a8))
+
+#### Documentation
+
+* Updated compatibility report ([#3699](https://github.com/newrelic/node-newrelic/pull/3699)) ([40b6b81](https://github.com/newrelic/node-newrelic/commit/40b6b813e7b6490c2e866a33cb1a7492b35d2a36))
+
+### v13.11.0 (2026-01-29)
+
+#### Features
+
+* Added `timestamp` to AIM `LlmChatCompletionMessage` messages
+    * Added `timestamp` to AWS Bedrock `LlmChatCompletionMessage` ([#3685](https://github.com/newrelic/node-newrelic/pull/3685)) ([ea297c8](https://github.com/newrelic/node-newrelic/commit/ea297c86772c1ae377a16e636db8bbcf53ef1547))
+    * Added `timestamp` to Google Gen AI `LlmChatCompletionMessage` ([#3686](https://github.com/newrelic/node-newrelic/pull/3686)) ([f4dd09e](https://github.com/newrelic/node-newrelic/commit/f4dd09ec332c47396277f6aaeff2f6f15daad97a))
+    * Added `timestamp` to LangChain input `LlmChatCompletionMessage` ([#3658](https://github.com/newrelic/node-newrelic/pull/3658)) ([0bce235](https://github.com/newrelic/node-newrelic/commit/0bce235ce02f772bc089bf947afadf312c735c1b))
+* Added timestamp to OpenAI `LlmChatCompletionSummary` ([#3689](https://github.com/newrelic/node-newrelic/pull/3689)) ([55b0310](https://github.com/newrelic/node-newrelic/commit/55b03100323eefb3578816cff69f2b919e4b7bdd))
+* Additional support for partial granularity traces (Not available for production use)
+    * Added essential tracing mode for span links ([#3670](https://github.com/newrelic/node-newrelic/pull/3670)) ([83dfb84](https://github.com/newrelic/node-newrelic/commit/83dfb84b842e0245392425ce61e92a2789fcaf06))
+    * Updated `Supportability/Nodejs/PartialGranularity/NrIds/Dropped` metric to only keep track of spans that got dropped when `nr.ids` execeeded 63 spans. ([#3684](https://github.com/newrelic/node-newrelic/pull/3684)) ([9797cf3](https://github.com/newrelic/node-newrelic/commit/9797cf38aa2808b29da9623158edb221b1819548))
+
+#### Bug fixes
+
+* Added defensive code in `lib/subscribers/middleware-wrapper.js` to prevent crash when attempting to associate an error on an incoming http request ([#3697](https://github.com/newrelic/node-newrelic/pull/3697)) ([658e78b](https://github.com/newrelic/node-newrelic/commit/658e78ba564eae996d790bb3334bda6847c7e2bd))
+* Updated `pg` instrumentation to properly capture the TraceSegment duration for promise based queries ([#3695](https://github.com/newrelic/node-newrelic/pull/3695)) ([0051697](https://github.com/newrelic/node-newrelic/commit/005169776a3f3fe9d988174857b3c96e6131aea3))
+
+#### Code refactoring
+
+* Added AIM abstract subscribers and updated all AIM subscribers to use them ([#3676](https://github.com/newrelic/node-newrelic/pull/3676)) ([08cd38b](https://github.com/newrelic/node-newrelic/commit/08cd38b5b34b4f1a2636ccc12d359484af6b3e83))
+
+#### Documentation
+
+* Updated compatibility report ([#3675](https://github.com/newrelic/node-newrelic/pull/3675)) ([cc898f4](https://github.com/newrelic/node-newrelic/commit/cc898f4d8b0f520e120f330ff9e90fe7baaebedc))
+
+#### Miscellaneous chores
+
+* Added TimedEvent limit of 100 ([#3683](https://github.com/newrelic/node-newrelic/pull/3683)) ([0d595d8](https://github.com/newrelic/node-newrelic/commit/0d595d8579b5a58e49908bc24321ce7b526ddff2))
+* Added supportability metrics `Supportability/Nodejs/SpanEvent/<Links|Events>/Dropped` when limit of 100 is exceeded ([#3688](https://github.com/newrelic/node-newrelic/pull/3688)) ([a247d31](https://github.com/newrelic/node-newrelic/commit/a247d31fc9c24752be50a73d4ddfc7a088a68ce6))
+* Removed eslint disable next line for `sonarjs/no-dead-store` ([#3692](https://github.com/newrelic/node-newrelic/pull/3692)) ([593fa15](https://github.com/newrelic/node-newrelic/commit/593fa15a033437b95fe375cf6034b8453c7d2b36))
+
+#### Continuous Integration
+* Fixed CI issue when sec-agent present ([#3677](https://github.com/newrelic/node-newrelic/pull/3677)) ([23da654](https://github.com/newrelic/node-newrelic/commit/23da6547e72f49bf798046330e8cfa74a0b4d2af))
+
+#### Tests
+
+* Assert that span events drop in partial traces ([#3680](https://github.com/newrelic/node-newrelic/pull/3680)) ([25e3781](https://github.com/newrelic/node-newrelic/commit/25e3781098343b9ca9e4aed0cd5c9e0f94266926))
+
 ### v13.10.0 (2026-01-20)
 
 #### Features

package/lib/instrumentation/aws-sdk/v3/bedrock.js

@@ -75,9 +75,10 @@ function isStreamingEnabled({ commandName, config }) {
 function recordEvent({ agent, type, msg }) {
   msg.serialize()
   const llmContext = extractLlmContext(agent)
+  const timestamp = msg?.timestamp ?? Date.now()
 
   agent.customEventAggregator.add([
-    { type, timestamp: Date.now() },
+    { type, timestamp },
     Object.assign({}, msg, llmContext)
   ])
 }

package/lib/instrumentation/when/index.js

@@ -296,7 +296,6 @@ module.exports = function initialize(shim, when) {
         ret = agent.tracer.bindFunction(fn, context, true).apply(this, arguments)
       } finally {
         if (ret && typeof ret.then === 'function') {
-          // eslint-disable-next-line sonarjs/no-dead-store
           ret = ctx.next[symbols.context].continue(ret)
         }
       }

package/lib/llm-events/aws-bedrock/chat-completion-message.js

@@ -38,7 +38,7 @@ class LlmChatCompletionMessage extends LlmEvent {
     params = Object.assign({}, defaultParams, params)
     super(params)
 
-    const { agent, content, isResponse, index, completionId, role } = params
+    const { agent, content, isResponse, index, completionId, role, segment } = params
     const recordContent = agent.config?.ai_monitoring?.record_content?.enabled
 
     this.is_response = isResponse
@@ -46,6 +46,10 @@ class LlmChatCompletionMessage extends LlmEvent {
     this.sequence = index
     this.content = recordContent === true ? content : undefined
     this.role = role
+    if (this.is_response === false) {
+      // Only record for request/input messages
+      this.timestamp = segment.timer.start
+    }
 
     this.#setId(index)
     this.setTokenCount(agent)

package/lib/llm-events/aws-bedrock/chat-completion-summary.js

@@ -37,6 +37,7 @@ class LlmChatCompletionSummary extends LlmEvent {
     this['request.temperature'] = cmd.temperature
     this['response.number_of_messages'] = (cmd.prompt.length ?? 0) + (res.completions.length ?? 0)
 
+    this.timestamp = segment.timer.start
     this.setTokens(agent)
   }
 

package/lib/llm-events/error-message.js

@@ -21,20 +21,26 @@ module.exports = class LlmErrorMessage {
    * @param {LlmVectorStoreSearch} [params.vectorsearch] Details about the vector
    * search if it was a vector search event.
    * @param {LlmTool} [params.tool] Details about the tool event if it was a tool event.
+   * @param {object} [params.aiAgent] Details about the AI agent event if it was an AI agent event.
    * @param {boolean} [params.useNameAsCode] defaults to false, only Bedrock sets it to true so far
    */
-  constructor({ response, cause, summary = {}, embedding = {}, vectorsearch = {}, tool = {}, useNameAsCode = false } = {}) {
+  constructor({ response, cause, summary = {}, embedding = {}, vectorsearch = {}, tool = {}, aiAgent = {}, useNameAsCode = false } = {}) {
     this['http.statusCode'] = response?.statusCode ?? response?.status ?? cause?.status
     this['error.message'] = cause?.message
-    this['error.code'] = response?.code ?? cause?.error?.code
+    this['error.code'] = response?.code ?? cause?.error?.code ?? cause?.code
     if (useNameAsCode) {
       this['error.code'] = cause?.name
     }
+    if (cause?.['lc_error_code']) {
+      // this is where langchain error codes live
+      this['error.code'] = cause['lc_error_code']
+    }
     this['error.param'] = response?.param ?? cause?.error?.param
     this.completion_id = summary?.id
     this.embedding_id = embedding?.id
     this.vector_store_id = vectorsearch?.id
     this.tool_id = tool?.id
+    this.agent_id = aiAgent?.id
 
     if (embedding?.vendor === 'gemini' || summary?.vendor === 'gemini') {
       this._handleGemini(cause)

package/lib/llm-events/google-genai/chat-completion-message.js

@@ -33,6 +33,11 @@ module.exports = class LlmChatCompletionMessage extends LlmEvent {
       this.content = this.is_response ? message?.parts?.[0]?.text : message
     }
 
+    // only add timestamp for request/input messages
+    if (this.is_response === false) {
+      this.timestamp = segment.timer.start
+    }
+
     this.setTokenCount(agent, request, response)
   }
 

package/lib/llm-events/google-genai/chat-completion-summary.js

@@ -21,6 +21,7 @@ module.exports = class LlmChatCompletionSummary extends LlmEvent {
     this['request.max_tokens'] = request.config?.maxOutputTokens
     this['request.temperature'] = request.config?.temperature
 
+    this.timestamp = segment.timer.start
     this.setTokens(agent, request, response)
   }
 

package/lib/llm-events/langchain/chat-completion-message.js

@@ -38,19 +38,25 @@ class LangChainCompletionMessage extends LangChainEvent {
   constructor(params = defaultParams) {
     params = Object.assign({}, defaultParams, params)
     super(params)
-    const { agent } = params
+    const { agent, runId, segment, sequence, role, content, completionId, isResponse } = params
 
-    if (params.runId) {
-      this.id = `${params.runId}-${params.sequence}`
+    if (runId) {
+      this.id = `${runId}-${sequence}`
     } else {
-      this.id = `${this.id}-${params.sequence}`
+      this.id = `${this.id}-${sequence}`
     }
 
-    this.sequence = params.sequence
-    this.completion_id = params.completionId
-    this.is_response = params.isResponse ?? false
-    if (params.role) {
-      this.role = params.role
+    this.sequence = sequence
+    this.completion_id = completionId
+
+    this.is_response = isResponse ?? false
+    if (this.is_response === false) {
+      // `timestamp` is only required for input/request messages.
+      this.timestamp = segment.timer.start
+    }
+
+    if (role) {
+      this.role = role
     } else {
       // As a backup, we can infer the role based on if it
       // is a response or not.
@@ -58,7 +64,7 @@ class LangChainCompletionMessage extends LangChainEvent {
     }
 
     if (agent.config.ai_monitoring.record_content.enabled === true) {
-      this.content = params.content
+      this.content = content
     }
   }
 }

package/lib/llm-events/langchain/chat-completion-summary.js

@@ -33,8 +33,9 @@ class LangChainCompletionSummary extends LangChainEvent {
     super(params)
     const { segment } = params
 
-    this.duration = segment?.getDurationInMillis()
+    this.duration = segment.getDurationInMillis()
     this['response.number_of_messages'] = params.messages?.length
+    this.timestamp = segment.timer.start
   }
 }
 

package/lib/llm-events/langgraph/agent.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const BaseLlmEvent = require('../event')
+const { makeId } = require('../../util/hashes')
+
+/**
+ * @typedef {object} LangGraphAgentEventParams
+ * @property {Agent} agent The New Relic agent instance.
+ * @property {string} name The name of the LangGraph agent, defaults to 'agent'.
+ * @property {object} segment The associated NR segment.
+ * @property {object} transaction The associated NR transaction.
+ * @property {boolean} error A boolean flag to indicate if an error occurred.
+ */
+
+module.exports = class LangGraphAgentEvent extends BaseLlmEvent {
+  id = makeId(36)
+  span_id
+  trace_id
+  ingest_source = 'Node'
+  vendor = 'langgraph'
+
+  /**
+   * @param {LangGraphAgentEventParams} params should contain all necessary and optional LangGraph data
+   */
+  constructor(params) {
+    super(params)
+    const { agent, segment, transaction, error = false, name = 'agent' } = params
+
+    this.name = name
+    this.span_id = segment.id
+    this.trace_id = transaction.traceId
+    this.error = error
+
+    // Setting `metadata` as the NR agent instance will allow `BaseLlmEvent`
+    // to extract the relevant `llm.<user_defined_metadata>`.
+    this.metadata = agent
+  }
+}

package/lib/llm-events/openai/chat-completion-summary.js

@@ -14,17 +14,19 @@ module.exports = class LlmChatCompletionSummary extends LlmEvent {
     this['request.temperature'] = request.temperature
 
     if (request?.input) {
-      // `responses.create` logic
+      // `responses.create` api logic
       // `request.input` can be an array or a string.
       const requestLength = Array.isArray(request?.input) ? request.input.length : 1
       this['response.number_of_messages'] = requestLength + (response?.output?.length ?? 0)
       this['response.choices.finish_reason'] = response?.status
     } else {
-      // `chat.completions.create` logic
+      // `chat.completions.create` api logic
       this['response.number_of_messages'] = request?.messages?.length + response?.choices?.length
       this['response.choices.finish_reason'] = response?.choices?.[0]?.finish_reason
     }
 
+    this.timestamp = segment.timer.start
+
     this.setTokens(agent, request, response)
   }
 

package/lib/metrics/names.js

@@ -171,7 +171,8 @@ const AI = {
   COMPLETION: 'Llm/completion',
   TOOL: 'Llm/tool',
   CHAIN: 'Llm/chain',
-  VECTORSTORE: 'Llm/vectorstore'
+  VECTORSTORE: 'Llm/vectorstore',
+  AGENT: 'Llm/agent'
 }
 
 AI.GEMINI = {
@@ -199,6 +200,11 @@ AI.LANGCHAIN = {
   VECTORSTORE: `${AI.VECTORSTORE}/LangChain`
 }
 
+AI.LANGGRAPH = {
+  TRACKING_PREFIX: `${AI.TRACKING_PREFIX}/LangGraph`,
+  AGENT: `${AI.AGENT}/LangGraph`
+}
+
 const MCP = {
   TRACKING_PREFIX: `${AI.TRACKING_PREFIX}/MCP`,
   TOOL: `${AI.TOOL}/MCP`,
@@ -325,7 +331,9 @@ const SPAN_EVENTS = {
   SEEN: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'TotalEventsSeen',
   SENT: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'TotalEventsSent',
   DROPPED: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'Discarded',
-  LIMIT: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'Limit'
+  LIMIT: SUPPORTABILITY.PREFIX + SPAN_EVENT_PREFIX + 'Limit',
+  LINKS_DROPPED: SUPPORTABILITY.NODEJS + '/' + SPAN_EVENT_PREFIX + 'Links/Dropped',
+  EVENTS_DROPPED: SUPPORTABILITY.NODEJS + '/' + SPAN_EVENT_PREFIX + 'Events/Dropped'
 }
 
 const INFINITE_TRACING = {

package/lib/otel/traces/span-processor.js

@@ -23,6 +23,7 @@ const {
   transformTemplate
 } = require('./utils.js')
 const defaultLogger = require('#agentlib/logger.js').child({ component: 'span-processor' })
+const { SPAN_EVENTS } = require('#agentlib/metrics/names.js')
 
 const {
   SPAN_STATUS_CODE
@@ -155,7 +156,10 @@ module.exports = class NrSpanProcessor {
         event: span.events[i],
         spanContext
       })
-      segment.addTimedEvent(event)
+      const added = segment.addTimedEvent(event)
+      if (!added) {
+        this.agent.metrics.getOrCreateMetric(SPAN_EVENTS.EVENTS_DROPPED).incrementCallCount()
+      }
     }
   }
 
@@ -181,7 +185,10 @@ module.exports = class NrSpanProcessor {
         spanContext,
         timestamp
       })
-      segment.addSpanLink(link)
+      const added = segment.addSpanLink(link)
+      if (!added) {
+        this.agent.metrics.getOrCreateMetric(SPAN_EVENTS.LINKS_DROPPED).incrementCallCount()
+      }
     }
   }
 

package/lib/spans/span-event.js

@@ -60,6 +60,8 @@ class SpanIntrinsics {
     this.duration = null
     this['nr.entryPoint'] = null
     this['nr.pg'] = null
+    this['nr.durations'] = null
+    this['nr.ids'] = null
     this['span.kind'] = null
     this.trustedParentId = null
     this.tracingVendors = null
@@ -316,6 +318,14 @@ class SpanEvent {
    *  @returns {SpanEvent|null} the span after applying the rules, or null if dropped
    */
   applyPartialTraceRules({ isEntry, partialTrace }) {
+    // in essential and compact mode - we need to remove the non intrinsic attributes from span links early in this process because there can be an entry span,
+    // llm span exit span or span with no entity relationship attributes can have non intrinsics on it.
+    if (partialTrace.type !== PARTIAL_TYPES.REDUCED) {
+      for (const link of this.spanLinks) {
+        link.removeNonIntrinsicsAttrs()
+      }
+    }
+
     if (isEntry) {
       this.addIntrinsicAttribute('nr.pg', true)
       logger.trace('Span %s is an entry point, keeping span unchanged.', this.intrinsics.name)

package/lib/spans/span-link.js

@@ -86,6 +86,11 @@ class SpanLink {
       filterNulls(this.agentAttributes.get(DESTINATIONS.TRANS_SEGMENT))
     ]
   }
+
+  removeNonIntrinsicsAttrs() {
+    this.userAttributes = Object.create(null)
+    this.agentAttributes = Object.create(null)
+  }
 }
 
 function filterNulls(inputObj) {

package/lib/subscriber-configs.js

@@ -18,6 +18,7 @@ const subscribers = {
   ...require('./subscribers/ioredis/config'),
   ...require('./subscribers/iovalkey/config'),
   ...require('./subscribers/langchain/config'),
+  ...require('./subscribers/langgraph/config'),
   ...require('./subscribers/mcp-sdk/config'),
   ...require('./subscribers/mysql/config'),
   ...require('./subscribers/mysql2/config'),

package/lib/subscribers/ai-monitoring/base.js

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const Subscriber = require('../base')
+const { DESTINATIONS } = require('#agentlib/config/attribute-filter.js')
+const { extractLlmContext } = require('#agentlib/util/llm-utils.js')
+
+class AiMonitoringSubscriber extends Subscriber {
+  /**
+   * @param {object} params constructor params object
+   * @param {object} params.agent A New Relic Node.js agent instance.
+   * @param {object} params.logger An agent logger instance.
+   * @param {string} params.packageName The package name being instrumented.
+   * This is what a developer would provide to the `require` function.
+   * @param {string} params.channelName A unique name for the diagnostics channel
+   * that will be created and monitored.
+   * @param {string} params.name name of segment for a given subscriber
+   * @param {string} params.trackingPrefix prefix for the tracking metric for a given subscriber
+   */
+  constructor({ agent, logger, packageName, channelName, name, trackingPrefix }) {
+    super({ agent, logger, packageName, channelName })
+    this.name = name
+    this.trackingPrefix = trackingPrefix
+  }
+
+  get enabled() {
+    return super.enabled && this.agent.config.ai_monitoring.enabled === true
+  }
+
+  set name(name) {
+    if (!name) {
+      throw new Error('subscriber must pass in `name`')
+    }
+    this._name = name
+  }
+
+  get name() {
+    return this._name
+  }
+
+  set trackingPrefix(prefix) {
+    if (!prefix) {
+      throw new Error('subscriber must pass in `trackingPrefix`')
+    }
+    this._prefix = prefix
+  }
+
+  get trackingPrefix() {
+    return this._prefix
+  }
+
+  /**
+   * Increments the tracking metric and sets the llm attribute on transactions
+   *
+   * @param {object} params input params
+   * @param {Transaction} params.ctx active context
+   * @param {string} params.version package version
+   */
+  addLlmMeta({ ctx, version }) {
+    if (!ctx?.transaction) {
+      return
+    }
+
+    const transaction = ctx.transaction
+    const trackingMetric = `${this.trackingPrefix}/${version}`
+    this.agent.metrics.getOrCreateMetric(trackingMetric).incrementCallCount()
+    transaction.trace.attributes.addAttribute(DESTINATIONS.TRANS_EVENT, 'llm', true)
+  }
+
+  /**
+   * Enqueues a LLM event to the custom event aggregator
+   *
+   * @param {object} params input params
+   * @param {string} params.type LLM event type
+   * @param {object} params.msg LLM event
+   */
+  recordEvent({ type, msg }) {
+    const llmContext = extractLlmContext(this.agent)
+    // prefer timestamp on event if present, otherwise use `Date.now`
+    const timestamp = msg?.timestamp ?? Date.now()
+    this.agent.customEventAggregator.add([
+      { type, timestamp },
+      Object.assign({}, msg, llmContext)
+    ])
+  }
+
+  /**
+   * Defines the common handler for all AIM calls.
+   * All of these calls simply create a segment with a name
+   * The `this.name` must be defined in the inherited subscriber
+   * @param {object} data event passed to handler
+   * @param {Context} ctx context passed to handler
+   * @returns {Context} either new context or existing
+   */
+  handler(data, ctx) {
+    if (!this.enabled) {
+      this.logger.debug('`ai_monitoring.enabled` is set to false, not creating segment.')
+      return ctx
+    }
+
+    this.addLlmMeta({ ctx, version: data.moduleVersion })
+
+    return this.createSegment({
+      name: this.name,
+      ctx
+    })
+  }
+}
+
+module.exports = AiMonitoringSubscriber

package/lib/subscribers/ai-monitoring/chat.js

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2026 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const AiMonitoringSubscriber = require('./base')
+const LlmErrorMessage = require('#agentlib/llm-events/error-message.js')
+
+class AiMonitoringChatSubscriber extends AiMonitoringSubscriber {
+  /**
+   * @param {object} params constructor params object
+   * @param {object} params.agent A New Relic Node.js agent instance.
+   * @param {object} params.logger An agent logger instance.
+   * @param {string} params.packageName The package name being instrumented.
+   * This is what a developer would provide to the `require` function.
+   * @param {string} params.channelName A unique name for the diagnostics channel
+   * that will be created and monitored.
+   * @param {string} params.name name of segment for a given subscriber
+   * @param {string} params.trackingPrefix prefix for the tracking metric for a given subscriber
+   */
+  constructor({ agent, logger, packageName, channelName, name, trackingPrefix }) {
+    super({ agent, logger, packageName, channelName, name, trackingPrefix })
+  }
+
+  get streamingEnabled() {
+    return this.agent.config.ai_monitoring.streaming.enabled === true
+  }
+
+  /**
+   * Function that must be implemented by inherited subscriber to create an llm completion message.
+   *
+   * @param {object} params to function
+   * @param {Context} params.ctx active context
+   * @param {object} params.request request made to method on a given llm library
+   * @param {object} params.response response from method on a given llm library
+   * @param {object|string} params.message the message object/string used to create llm completion message
+   * @param {string} params.completionId the id of the llm completion summary for a given conversation
+   * @param {number} params.index index of message for a given conversation
+   * returns {object} a llm completion message instance for the given LLM
+   */
+  createCompletionMessage({ ctx, request, response, message, completionId, index }) {
+    throw new Error('createCompletionMessage must be implemented by your subscriber')
+  }
+
+  /**
+   * Function that must be implemented by inherited subscriber to create the llm completion summary.
+   *
+   * @param {object} params to function
+   * @param {Context} params.ctx active context
+   * @param {object} params.request request made to method on a given llm library
+   * @param {object} params.response response from method on a given llm library
+   * @param {object} params.err error if present
+   * @param {object} params.metadata used only for langchain events at the moment
+   * @param {Array} params.tags used only for langchain events at the moment
+   * returns {object} a llm completion summary instance for the given LLM
+   */
+  createCompletionSummary({ ctx, request, response, err, metadata, tags }) {
+    throw new Error('createCompletionSummary must be implemented by your subscriber')
+  }
+
+  /**
+   * Function that must be implemented by inherited subscriber to retrieve the relevant
+   * messages for a given chat conversation.
+   *
+   * @param {object} params to function
+   * @param {object} params.request request to instrumented function
+   * @param {object} params.response response to instrumented function
+   * returns {Array} an array of relevant messages used to construct llm completion messages
+   */
+  getMessages({ request, response }) {
+    throw new Error('getMessages must be implemented by your subscriber')
+  }
+
+  /**
+   * Function to create both llm completion summary and messages
+   *  as well as assign errors to transaction if present
+   * @param {object} params to function
+   * @param {Context} params.ctx active context
+   * @param {object} params.request request made to method on a given llm library
+   * @param {object} params.response response from method on a given llm library
+   * @param {object} params.err error if present
+   * @param {object} params.metadata used only for langchain events at the moment
+   * @param {Array} params.tags used only for langchain events at the moment
+   */
+  recordChatCompletionEvents({ ctx, request, response, err, metadata = {}, tags = [] }) {
+    if (!this.enabled) {
+      this.logger.debug('config.ai_monitoring.enabled is set to false, not creating chat completion events.')
+      return
+    }
+
+    if (!(ctx?.segment || ctx?.transaction)) {
+      this.logger.debug('Empty context, not creating completion events.')
+      return
+    }
+
+    // Explicitly end segment to provide consistent duration
+    // for both LLM events and the segment
+    ctx.segment.end()
+    const completionSummary = this.createCompletionSummary({ ctx, request, response, err, metadata, tags })
+    this.recordEvent({ type: 'LlmChatCompletionSummary', msg: completionSummary })
+
+    const messages = this.getMessages({ request, response })
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i]
+      const completionMessage = this.createCompletionMessage({ ctx, completionId: completionSummary.id, index: i, message, request, response })
+      this.recordEvent({ type: 'LlmChatCompletionMessage', msg: completionMessage })
+    }
+
+    if (err) {
+      const llmError = new LlmErrorMessage({ cause: err, summary: completionSummary, response })
+      this.agent.errors.add(ctx.transaction, err, llmError)
+    }
+  }
+}
+
+module.exports = AiMonitoringChatSubscriber