newrelic 12.24.0 → 12.25.0

package/NEWS.md

@@ -1,3 +1,22 @@
+### v12.25.0 (2025-07-09)
+
+#### Features
+
+* Instrument AWS Bedrock Converse API ([#3191](https://github.com/newrelic/node-newrelic/pull/3191)) ([16ac684](https://github.com/newrelic/node-newrelic/commit/16ac6845a82506bbdd0e51f3f9a6d05ac8016246))
+
+#### Bug fixes
+
+* `eventSegment.addAttribute` will not crash if null ([#3215](https://github.com/newrelic/node-newrelic/pull/3215)) ([8955f37](https://github.com/newrelic/node-newrelic/commit/8955f3737e686b4bf6beab2d4e53a1f5eb221166))
+* `openai` Responses API support changed to >=v4.87.0 ([#3219](https://github.com/newrelic/node-newrelic/pull/3219)) ([19c0c70](https://github.com/newrelic/node-newrelic/commit/19c0c7011c8c877098c5a57063354f01f5f83295))
+
+#### Documentation
+
+* Updated compatibility report ([#3220](https://github.com/newrelic/node-newrelic/pull/3220)) ([b4350c7](https://github.com/newrelic/node-newrelic/commit/b4350c7e3a718e47d066c5c2c1f4f5f20f43e52c))
+
+#### Miscellaneous chores
+
+* Converted .proto to .json for bundling ([#3212](https://github.com/newrelic/node-newrelic/pull/3212)) ([1e208d4](https://github.com/newrelic/node-newrelic/commit/1e208d43acc1811674126b6aa987c895178f4fc3))
+
 ### v12.24.0 (2025-07-07)
 
 #### Features

package/lib/grpc/connection.js

@@ -22,7 +22,7 @@ const connectionStates = require('./connection/states')
 
 const PROTO_OPTIONS = { keepCase: true, longs: String, enums: String, defaults: true, oneofs: true }
 
-const PROTO_DEFINITION_PATH = __dirname + '../../../lib/grpc/endpoints/infinite-tracing/v1.proto'
+const PROTO_DEFINITION = require('./endpoints/infinite-tracing/v1.json')
 
 const DEFAULT_RECONNECT_DELAY_MS = 15 * 1000
 
@@ -369,7 +369,7 @@ class GrpcConnection extends EventEmitter {
     const endpoint = this._endpoint
     logger.trace('Creating gRPC client for: ', endpoint)
 
-    const packageDefinition = protoLoader.loadSync(PROTO_DEFINITION_PATH, PROTO_OPTIONS)
+    const packageDefinition = protoLoader.fromJSON(PROTO_DEFINITION, PROTO_OPTIONS)
 
     const protoDescriptor = grpc.loadPackageDefinition(packageDefinition)
 

package/lib/grpc/endpoints/infinite-tracing/Readme.md

@@ -0,0 +1,10 @@
+The `.proto` files in this directory are provided by New Relic internal
+specifications.
+
+The `.json` files in this directory are JSON descriptor files derived from
+the equivalent `.proto` files. This is accomplished by utilizing the CLI
+tool provided by `protobufjs`. As an example:
+
+```sh
+npx --package=protobufjs-cli -c 'pbjs --keep-case v1.proto' > v1.json
+```

package/lib/grpc/endpoints/infinite-tracing/v1.json

@@ -0,0 +1,106 @@
+{
+  "nested": {
+    "com": {
+      "nested": {
+        "newrelic": {
+          "nested": {
+            "trace": {
+              "nested": {
+                "v1": {
+                  "nested": {
+                    "IngestService": {
+                      "methods": {
+                        "RecordSpan": {
+                          "requestType": "Span",
+                          "requestStream": true,
+                          "responseType": "RecordStatus",
+                          "responseStream": true
+                        },
+                        "RecordSpanBatch": {
+                          "requestType": "SpanBatch",
+                          "requestStream": true,
+                          "responseType": "RecordStatus",
+                          "responseStream": true
+                        }
+                      }
+                    },
+                    "SpanBatch": {
+                      "fields": {
+                        "spans": {
+                          "rule": "repeated",
+                          "type": "Span",
+                          "id": 1
+                        }
+                      }
+                    },
+                    "Span": {
+                      "fields": {
+                        "trace_id": {
+                          "type": "string",
+                          "id": 1
+                        },
+                        "intrinsics": {
+                          "keyType": "string",
+                          "type": "AttributeValue",
+                          "id": 2
+                        },
+                        "user_attributes": {
+                          "keyType": "string",
+                          "type": "AttributeValue",
+                          "id": 3
+                        },
+                        "agent_attributes": {
+                          "keyType": "string",
+                          "type": "AttributeValue",
+                          "id": 4
+                        }
+                      }
+                    },
+                    "AttributeValue": {
+                      "oneofs": {
+                        "value": {
+                          "oneof": [
+                            "string_value",
+                            "bool_value",
+                            "int_value",
+                            "double_value"
+                          ]
+                        }
+                      },
+                      "fields": {
+                        "string_value": {
+                          "type": "string",
+                          "id": 1
+                        },
+                        "bool_value": {
+                          "type": "bool",
+                          "id": 2
+                        },
+                        "int_value": {
+                          "type": "int64",
+                          "id": 3
+                        },
+                        "double_value": {
+                          "type": "double",
+                          "id": 4
+                        }
+                      }
+                    },
+                    "RecordStatus": {
+                      "fields": {
+                        "messages_seen": {
+                          "type": "uint64",
+                          "id": 1
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

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

@@ -19,9 +19,27 @@ const { AI } = require('../../../metrics/names')
 const { RecorderSpec } = require('../../../shim/specs')
 const InstrumentationDescriptor = require('../../../instrumentation-descriptor')
 const { extractLlmContext } = require('../../../util/llm-utils')
+const ConverseStreamHandler = require('../../../llm-events/aws-bedrock/converse-stream-handler')
 
 let TRACKING_METRIC
 
+const INSTRUMENTED_COMMANDS = new Set([
+  'InvokeModelCommand',
+  'InvokeModelWithResponseStreamCommand',
+  'ConverseCommand',
+  'ConverseStreamCommand'
+])
+
+const STREAMING_COMMANDS = new Set([
+  'InvokeModelWithResponseStreamCommand',
+  'ConverseStreamCommand'
+])
+
+const CONVERSE_COMMANDS = new Set([
+  'ConverseCommand',
+  'ConverseStreamCommand'
+])
+
 /**
  * Helper to determine if we should instrument the bedrock middleware call
  *
@@ -42,7 +60,7 @@ function shouldSkipInstrumentation(config) {
  */
 function isStreamingEnabled({ commandName, config }) {
   return (
-    commandName === 'InvokeModelWithResponseStreamCommand' &&
+    STREAMING_COMMANDS.has(commandName) &&
     config.ai_monitoring?.streaming?.enabled
   )
 }
@@ -242,6 +260,7 @@ function createBedrockResponse({ bedrockCommand, response, err }) {
 function getBedrockSpec({ commandName }, shim, _original, _name, args) {
   const { agent } = shim
   const { input } = args[0]
+  const isConverse = CONVERSE_COMMANDS.has(commandName)
   const bedrockCommand = new BedrockCommand(input)
   const { modelType } = bedrockCommand
 
@@ -261,17 +280,33 @@ function getBedrockSpec({ commandName }, shim, _original, _name, args) {
 
       if (err && !response) {
         handleResponse(passThroughParams)
-      } else if (response.output.body instanceof Uint8Array) {
+      } else if (response.output.body instanceof Uint8Array || 'output' in response.output) {
         // non-streamed response
         handleResponse(passThroughParams)
       } else if (isStreamingEnabled({ commandName, config: agent.config })) {
         // stream response
-        const handler = new StreamHandler({
-          stream: response.output.body,
-          onComplete: handleResponse,
-          passThroughParams
-        })
-        response.output.body = handler.generator(handleResponse)
+        if (isConverse) {
+          const handler = new ConverseStreamHandler({
+            stream: response.output.stream,
+            onComplete: handleResponse,
+            passThroughParams
+          })
+          response.output = {
+            ...response.output ?? {},
+            output: {
+              message: {
+                content: handler.generator(handleResponse)
+              }
+            }
+          }
+        } else {
+          const handler = new StreamHandler({
+            stream: response.output.body,
+            onComplete: handleResponse,
+            passThroughParams
+          })
+          response.output.body = handler.generator(handleResponse)
+        }
       } else if (!isStreamingEnabled({ commandName, config: agent.config })) {
         shim.logger.warn(
           'ai_monitoring.streaming.enabled is set to `false`, stream will not be instrumented.'
@@ -285,6 +320,11 @@ function getBedrockSpec({ commandName }, shim, _original, _name, args) {
 
 function handleResponse({ shim, err, response, segment, transaction, bedrockCommand, modelType }) {
   const { agent } = shim
+  // For the ConverseStreamHandler only, response.output does not
+  // contain stopReason yet, so we set it here.
+  if (response?.output && this?.stopReason) {
+    response.output.stopReason = this.stopReason
+  }
   const bedrockResponse = createBedrockResponse({ bedrockCommand, response, err })
 
   addLlmMeta({ agent, segment, transaction })
@@ -319,13 +359,12 @@ function handleResponse({ shim, err, response, segment, transaction, bedrockComm
  * @param {object} config AWS configuration object
  * @param {function} next the next middleware function in stack
  * @param {object} context AWS client context info
+ *
+ * @returns {function} the next middleware function in stack
  */
 function bedrockMiddleware(shim, config, next, context) {
   const { commandName } = context
-  if (
-    commandName === 'InvokeModelCommand' ||
-    commandName === 'InvokeModelWithResponseStreamCommand'
-  ) {
+  if (INSTRUMENTED_COMMANDS.has(commandName)) {
     return shim.record(next, getBedrockSpec.bind(null, { commandName }))
   }
 

package/lib/instrumentation/openai.js

@@ -394,10 +394,10 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
     }
   )
 
-  // New API introduced in openai@5.0.0
+  // New API introduced in openai@4.87.0
   // Also instruments chat completion creation
   // and creates the LLM events
-  if (semver.gte(shim.pkgVersion, '5.0.0')) {
+  if (semver.gte(shim.pkgVersion, '4.87.0')) {
     shim.record(openaiClient.Responses.prototype, 'create', function wrapCreate(shim, create, name, args) {
       const [request] = args
 

package/lib/llm-events/aws-bedrock/bedrock-command.js

@@ -5,25 +5,43 @@
 
 'use strict'
 
-const { stringifyClaudeChunkedMessage } = require('./utils')
+const { stringifyClaudeChunkedMessage, stringifyConverseChunkedMessage } = require('./utils')
 
 /**
- * Parses an AWS invoke command instance into a re-usable entity.
+ * Parses an AWS Bedrock command instance into a re-usable entity,
+ * unifying logic for both InvokeModel and Converse commands.
  */
 class BedrockCommand {
   #input
-  #body
   #modelId
+  #body
+  #messages
+  #isConverseCommand
 
   /**
-   * @param {object} input The `input` property from an InvokeModelCommand or
-   * InvokeModelWithResponseStreamCommand instance that is used for the
-   * conversation.
+   * @param {object} input The `input` property from an InvokeModelCommand,
+   * InvokeModelWithResponseStreamCommand, ConverseCommand, or
+   * ConverseStreamCommand instance.
    */
   constructor(input) {
     this.#input = input
-    this.#body = JSON.parse(this.#input.body)
     this.#modelId = this.#input.modelId?.toLowerCase() ?? ''
+
+    if (Object.hasOwn(input, 'body') === true) {
+      this.#body = JSON.parse(this.#input.body)
+      this.#isConverseCommand = false
+    } else if (Object.hasOwn(input, 'messages') === true) {
+      this.#messages = input.messages
+      this.#isConverseCommand = true
+    }
+  }
+
+  /**
+   *
+   * @returns {boolean} True if the command is from the Converse API.
+   */
+  get isConverse() {
+    return this.#isConverseCommand
   }
 
   /**
@@ -32,17 +50,24 @@ class BedrockCommand {
    * @returns {number|undefined}
    */
   get maxTokens() {
-    let result
-    if (this.isClaude() === true) {
-      result = this.#body.max_tokens_to_sample
-    } else if (this.isClaude3() === true || this.isCohere() === true) {
-      result = this.#body.max_tokens
-    } else if (this.isLlama() === true) {
-      result = this.#body.max_gen_length
-    } else if (this.isTitan() === true) {
-      result = this.#body.textGenerationConfig?.maxTokenCount
+    if (this.#isConverseCommand) {
+      // Logic for Converse
+      return this.#input?.inferenceConfig?.maxTokens
+    } else {
+      // Logic for InvokeModel
+      if (this.isClaude() === true) {
+        return this.#body.max_tokens_to_sample
+      }
+      if (this.isClaude3() === true || this.isCohere() === true) {
+        return this.#body.max_tokens
+      }
+      if (this.isLlama() === true) {
+        return this.#body.max_gen_length
+      }
+      if (this.isTitan() === true) {
+        return this.#body.textGenerationConfig?.maxTokenCount
+      }
     }
-    return result
   }
 
   /**
@@ -60,40 +85,53 @@ class BedrockCommand {
    * @returns {string} One of `embedding` or `completion`.
    */
   get modelType() {
-    // At the moment, this is a simple check. If Amazon ever introduces a
-    // complex identifier, we can implement a more complicated check.
+    // This logic is common to both command types
     return this.#modelId.toLowerCase().includes('embed') ? 'embedding' : 'completion'
   }
 
   /**
    * The question posed to the LLM.
    *
-   * @returns {object[]} The array of context messages passed to the LLM (or a single user prompt for legacy "non-chat" models)
+   * @returns {string|string[]|object[]}
    */
   get prompt() {
-    if (this.isTitan() === true || this.isTitanEmbed() === true) {
-      return [
-        {
-          role: 'user',
-          content: this.#body.inputText
+    if (this.#isConverseCommand) {
+      // Logic for Converse
+      const result = []
+      for (const message of this.#messages) {
+        // The `message.content` field is an array of ContentBlock objects.
+        // For text messages, the structure is: content: [{ text: '...' }]
+        if (Array.isArray(message?.content) === true) {
+          result.push({
+            role: message.role,
+            content: stringifyConverseChunkedMessage(message.content)
+          })
         }
-      ]
-    } else if (this.isCohereEmbed() === true) {
-      return [
-        {
-          role: 'user',
-          content: this.#body.texts.join(' ')
-        }
-      ]
-    } else if (
-      this.isClaudeTextCompletionApi() === true ||
-      this.isCohere() === true ||
-      this.isLlama() === true
+      }
+      return result
+    }
+
+    // Logic for InvokeModel
+    if (this.isTitan() || this.isTitanEmbed()) {
+      return [{ role: 'user', content: this.#body.inputText }]
+    }
+
+    if (this.isCohereEmbed()) {
+      return [{ role: 'user', content: this.#body.texts.join(' ') }]
+    }
+
+    if (
+      this.isClaudeTextCompletionApi(this.#body) ||
+      this.isCohere() ||
+      this.isLlama()
     ) {
       return [{ role: 'user', content: this.#body.prompt }]
-    } else if (this.isClaudeMessagesApi() === true) {
+    }
+
+    if (this.isClaudeMessagesApi(this.#body)) {
       return normalizeClaude3Messages(this.#body?.messages)
     }
+
     return []
   }
 
@@ -101,20 +139,25 @@ class BedrockCommand {
    * @returns {number|undefined}
    */
   get temperature() {
-    let result
+    if (this.#isConverseCommand) {
+      // Logic for Converse
+      return this.#input?.inferenceConfig?.temperature
+    }
+    // Logic for InvokeModel
     if (this.isTitan() === true) {
-      result = this.#body.textGenerationConfig?.temperature
-    } else if (
+      return this.#body.textGenerationConfig?.temperature
+    }
+    if (
       this.isClaude() === true ||
-      this.isClaude3() === true ||
-      this.isCohere() === true ||
-      this.isLlama() === true
+        this.isClaude3() === true ||
+        this.isCohere() === true ||
+        this.isLlama() === true
     ) {
-      result = this.#body.temperature
+      return this.#body.temperature
     }
-    return result
   }
 
+  // Helper methods that depend on modelId (common to both types)
   isClaude() {
     return this.#modelId.split('.').slice(-2).join('.').startsWith('anthropic.claude-v')
   }
@@ -143,21 +186,22 @@ class BedrockCommand {
     return this.#modelId.startsWith('amazon.titan-embed')
   }
 
-  isClaudeMessagesApi() {
-    return (this.isClaude3() === true || this.isClaude() === true) && 'messages' in this.#body
+  isClaudeMessagesApi(body) {
+    return (this.isClaude3() === true || this.isClaude() === true) && 'messages' in body
   }
 
-  isClaudeTextCompletionApi() {
-    return this.isClaude() === true && 'prompt' in this.#body
+  isClaudeTextCompletionApi(body) {
+    return this.isClaude() === true && 'prompt' in body
   }
 }
 
 /**
- * Claude v3 requests in Bedrock can have two different "chat" flavors. This function normalizes them into a consistent
+ * Claude v3 requests in Bedrock can have two different "chat" flavors.
+ * This function normalizes them into a consistent
  * format per the AIM agent spec
  *
- * @param messages - The raw array of messages passed to the invoke API
- * @returns {number|undefined} - The normalized messages
+ * @param {Array<object>} messages - The raw array of messages passed to the invoke API
+ * @returns {Array<object>} - The normalized messages
  */
 function normalizeClaude3Messages(messages) {
   const result = []

package/lib/llm-events/aws-bedrock/bedrock-response.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-const { stringifyClaudeChunkedMessage } = require('./utils')
+const { stringifyClaudeChunkedMessage, stringifyConverseChunkedMessage } = require('./utils')
 
 /**
  * @typedef {object} AwsBedrockMiddlewareResponse
@@ -18,60 +18,49 @@ const { stringifyClaudeChunkedMessage } = require('./utils')
  */
 
 /**
- * Represents a response from the Bedrock API. Given that the API response
- * has as many different shapes as the number of models it supports, and the
- * fact that responses require byte array processing, this object provides
- * an abstraction that normalizes responses into a known interface and
- * simplifies accessing desired fields.
+ * Represents a response from the Bedrock API, handling both standard and Converse API responses.
+ * This object provides an abstraction that normalizes responses into a known interface and
+ * simplifies accessing desired fields, accommodating the varied shapes of Bedrock API responses.
  */
 class BedrockResponse {
+  #originalResponse
   #innerResponse
   #innerOutput
   #parsedBody
+  #output
   #command
   #completions = []
   #id
+  #isConverse
 
   /**
    * @param {object} params
    * @param {AwsBedrockMiddlewareResponse} params.response
    * @param {BedrockCommand} params.bedrockCommand
-   * @param params.isError
+   * @param {boolean} params.isError
    */
   constructor({ response, bedrockCommand, isError = false }) {
+    this.#originalResponse = response
     this.#innerResponse = isError ? response.$response : response.response
     this.#command = bedrockCommand
     this.isError = isError
+    this.#isConverse = this.#command.isConverse ?? false
 
     if (this.isError) {
       return
     }
 
-    this.#innerOutput = response.output
-
-    const json = new TextDecoder().decode(this.#innerOutput.body)
-    this.#parsedBody = JSON.parse(json)
-
-    const cmd = this.#command
-    const body = this.#parsedBody
-    if (cmd.isClaude() === true) {
-      // TODO: can we make this thing give more than one completion?
-      body.completion && this.#completions.push(body.completion)
-    } else if (cmd.isClaude3() === true) {
-      if (body?.type === 'message_stop') {
-        // Streamed response
-        this.#completions = body.completions
-      } else {
-        this.#completions = [stringifyClaudeChunkedMessage(body?.content)]
-      }
-      this.#id = body.id
-    } else if (cmd.isCohere() === true) {
-      this.#completions = body.generations?.map((g) => g.text) ?? []
-      this.#id = body.id
-    } else if (cmd.isLlama() === true) {
-      body.generation && this.#completions.push(body.generation)
-    } else if (cmd.isTitan() === true) {
-      this.#completions = body.results?.map((r) => r.outputText) ?? []
+    if (this.#isConverse) {
+      this.#innerOutput = response.output.output
+      this.#output = this.#innerOutput.message
+    } else {
+      this.#innerOutput = response.output
+      const json = new TextDecoder().decode(this.#innerOutput.body)
+      this.#parsedBody = JSON.parse(json)
+
+      const cmd = this.#command
+      const body = this.#parsedBody
+      this.#extractCompletionsAndId(cmd, body)
     }
   }
 
@@ -82,32 +71,40 @@ class BedrockResponse {
    * prompt.
    */
   get completions() {
-    return this.#completions
+    if (this.#isConverse === false) {
+      return this.#completions
+    }
+    const content = this.#output?.content
+    if (!content) return []
+    return [typeof content === 'string' ? content : stringifyConverseChunkedMessage(content)]
   }
 
   /**
    * The reason the model has given for finishing the response.
    *
-   * @returns {string|*}
+   * @returns {string|undefined}
    */
   get finishReason() {
-    let result
-
     if (this.isError) {
-      return result
+      return undefined
+    }
+    if (this.#isConverse) {
+      return this.#originalResponse.output.stopReason
     }
-
     const cmd = this.#command
     if (cmd.isClaude() === true || cmd.isClaude3() === true) {
-      result = this.#parsedBody.stop_reason
-    } else if (cmd.isCohere() === true) {
-      result = this.#parsedBody.generations?.find((r) => r.finish_reason !== null)?.finish_reason
-    } else if (cmd.isLlama() === true) {
-      result = this.#parsedBody.stop_reason
-    } else if (cmd.isTitan() === true) {
-      result = this.#parsedBody.results?.find((r) => r.completionReason !== null)?.completionReason
+      return this.#parsedBody.stop_reason
+    }
+    if (cmd.isCohere() === true) {
+      return this.#parsedBody.generations?.find((r) => r.finish_reason !== null)?.finish_reason
+    }
+    if (cmd.isLlama() === true) {
+      return this.#parsedBody.stop_reason
     }
-    return result
+    if (cmd.isTitan() === true) {
+      return this.#parsedBody.results?.find((r) => r.completionReason !== null)?.completionReason
+    }
+    return undefined
   }
 
   /**
@@ -125,7 +122,8 @@ class BedrockResponse {
    * @returns {string|undefined}
    */
   get id() {
-    return this.#id
+    // For Converse API, the requestId serves as the id.
+    return this.#isConverse ? this.requestId : this.#id
   }
 
   /**
@@ -146,12 +144,30 @@ class BedrockResponse {
     return this.#innerResponse.statusCode
   }
 
-  #tokenCount(headerName) {
-    const headerVal = this.headers?.[headerName]
-    if (headerVal != null) {
-      return parseInt(headerVal, 10)
+  /**
+   * Extracts and sets #completions and #id from the InvokeModel response body.
+   * @param {BedrockCommand} cmd
+   * @param {*} body
+   */
+  #extractCompletionsAndId(cmd, body) {
+    if (cmd.isClaude() === true) {
+      body.completion && this.#completions.push(body.completion)
+    } else if (cmd.isClaude3() === true) {
+      if (body?.type === 'message_stop') {
+        // Streamed response
+        this.#completions = body.completions
+      } else {
+        this.#completions = [stringifyClaudeChunkedMessage(body?.content)]
+      }
+      this.#id = body.id
+    } else if (cmd.isCohere() === true) {
+      this.#completions = body.generations?.map((g) => g.text) ?? []
+      this.#id = body.id
+    } else if (cmd.isLlama() === true) {
+      body.generation && this.#completions.push(body.generation)
+    } else if (cmd.isTitan() === true) {
+      this.#completions = body.results?.map((r) => r.outputText) ?? []
     }
-    return undefined
   }
 }
 

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

@@ -57,7 +57,7 @@ class LlmChatCompletionMessage extends LlmEvent {
 
   #setId(index) {
     const cmd = this.bedrockCommand
-    if (cmd.isTitan() === true || cmd.isClaude() === true) {
+    if (cmd.isConverse || cmd.isTitan() === true || cmd.isClaude() === true) {
       this.id = `${this.id}-${index}`
     } else if (cmd.isCohere() === true) {
       this.id = `${this.bedrockResponse.id || this.id}-${index}`

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

@@ -27,16 +27,14 @@ class LlmChatCompletionSummary extends LlmEvent {
     const { segment, isError } = params
     this.error = isError
     this.duration = segment.getDurationInMillis()
-    this['request.max_tokens'] = this.bedrockCommand.maxTokens
-
-    const nm = 'response.number_of_messages'
-    const cfr = 'response.choices.finish_reason'
-    const rt = 'request.temperature'
 
     const cmd = this.bedrockCommand
-    this[cfr] = this.bedrockResponse.finishReason
-    this[rt] = cmd.temperature
-    this[nm] = (this.bedrockCommand.prompt.length) + this.bedrockResponse.completions.length
+    const res = this.bedrockResponse
+
+    this['request.max_tokens'] = cmd.maxTokens
+    this['response.choices.finish_reason'] = res.finishReason
+    this['request.temperature'] = cmd.temperature
+    this['response.number_of_messages'] = (cmd.prompt.length ?? 0) + (res.completions.length ?? 0)
   }
 }
 

package/lib/llm-events/aws-bedrock/converse-stream-handler.js

@@ -0,0 +1,155 @@
+/*
+ * Copyright 2025 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+/**
+ * A stream handler processes a streamed response from the Bedrock API by
+ * intercepting each stream event, passing that event unmodified up to the
+ * consuming client, and then collecting the information into an "API response"
+ * object that satisfies the requirements of {@link BedrockResponse}. Once the
+ * stream has reached its end, the handler applies some finalizations to the
+ * compiled response object, updates the pass through parameters with the new
+ * object, and then invokes the final response handler passed in through
+ * `onComplete`.
+ */
+class ConverseStreamHandler {
+  // We have to make most of the properties of this object public so that
+  // the at-construction-time attached generator function can access them
+  // through the `this` reference. See https://jrfom.com/posts/2023/10/31/js-classes/
+  // for details on why this is necessary.
+
+  /**
+   * The parameters to pass through to the `onComplete` function once the
+   * stream has been processed. The `response` property on this object will
+   * be overwritten with the response object that has been compiled by the
+   * stream handler.
+   */
+  passThroughParams
+
+  /**
+   * The original async iterable returned from the AWS SDK.
+   */
+  stream
+
+  /**
+   * The New Relic agent's internal trace segment. The `.touch` method will be
+   * used to mark the end time of the stream processing.
+   */
+  segment
+
+  /**
+   * For streaming messages, we want to capture the effective message chunks like we would see in the non-streaming API
+   */
+  observedChunks = []
+
+  stopReason
+
+  /**
+   * Represents an API response object as {@link BedrockResponse} expects.
+   * It will be updated by the stream handler with information received
+   * during processing of the stream. Upon stream completion, this object
+   * will replace the `response` property of `passThroughParams`.
+   *
+   * @type {object}
+   */
+  response = {
+    response: {
+      headers: {},
+      statusCode: 200
+    },
+    output: {
+      output: {
+        message: {
+
+        }
+      }
+    }
+  }
+
+  /**
+   * The function that will be invoked once the stream processing has finished.
+   * It will receive `this.passThroughParams` as the only parameter.
+   */
+  onComplete
+
+  constructor({ stream, passThroughParams, onComplete }) {
+    this.passThroughParams = passThroughParams
+    this.stream = stream
+    this.onComplete = onComplete
+    this.segment = passThroughParams.segment
+    this.generator = handleConverse
+  }
+
+  /**
+   * Encodes the output body into a Uint8Array, updates the pass through
+   * parameters with the compiled response object, and invokes the response
+   * handler. The trace segment is also updated to mark the end of the stream
+   * processing and account for the time it took to process the stream within
+   * the trace.
+   */
+  finish() {
+    this.passThroughParams.response = this.response
+    this.onComplete(this.passThroughParams)
+
+    this.segment.touch()
+  }
+
+  /**
+   * If the given event is the last event in the stream, update the response
+   * headers with the metrics data from the event.
+   *
+   * @param {object} parsedEvent
+   */
+  updateHeaders(parsedEvent) {
+    this.response.response.headers = {
+      'x-amzn-requestid': this.passThroughParams.response.response.headers['x-amzn-requestid']
+    }
+    delete parsedEvent['amazon-bedrock-invocationMetrics']
+  }
+}
+
+// eslint-disable-next-line sonarjs/cognitive-complexity
+async function * handleConverse() {
+  let activeChunk = null
+
+  try {
+    for await (const event of this.stream) {
+      yield event
+      this.updateHeaders(event)
+      if (event.messageStart?.role) {
+        this.role = 'assistant'
+      } else if (event.contentBlockStart?.start) {
+        // Handles a Content block start event. Tool use only.
+        const blockStartData = event.contentBlockStart.start
+        if (blockStartData.toolUse) {
+          activeChunk = { toolUse: { name: blockStartData.toolUse.name } }
+        }
+      } else if (event.contentBlockStop) {
+        if (activeChunk !== null) {
+          this.observedChunks.push(activeChunk)
+          activeChunk = null
+        }
+      } else if (event.contentBlockDelta?.delta) {
+        if (event.contentBlockDelta.delta.text) {
+          // It seems like the first streamed chunk does not always start with a contentBlockStart message
+          // If the stream starts with a delta, assume the current chunk is text
+          if (activeChunk === null) {
+            activeChunk = { text: '' }
+          }
+          activeChunk.text += event.contentBlockDelta.delta.text
+        }
+        // There are also deltas for tool use (stringified inputs) but we don't currently record them so we just ignore for now
+      } else if (event.messageStop) {
+        this.stopReason = event.messageStop?.stopReason
+      }
+    }
+  } finally {
+    this.response.output.output.message.content = this.observedChunks
+    this.finish()
+  }
+}
+
+module.exports = ConverseStreamHandler

package/lib/llm-events/aws-bedrock/index.js

@@ -13,5 +13,6 @@ module.exports = {
   LlmEmbedding: require('./embedding'),
   LlmEvent: require('./event'),
   LlmError: require('./error'),
-  StreamHandler: require('./stream-handler')
+  StreamHandler: require('./stream-handler'),
+  ConverseStreamHandler: require('./converse-stream-handler')
 }

package/lib/llm-events/aws-bedrock/utils.js

@@ -31,6 +31,43 @@ function stringifyClaudeChunkedMessage(chunks) {
   return stringifiedChunks.join('\n\n')
 }
 
+/**
+ *
+ * @param {object[]} chunks - The "chunks" that make up a single conceptual message. In a multi-modal scenario, a single message
+ * might have a number of different-typed chunks interspersed
+ * @returns {string} - A stringified version of the message. We make a best-effort effort attempt to represent non-text chunks. In the future
+ * we may want to extend the agent to support these non-text chunks in a richer way. Placeholders are represented in an XML-like format but
+ * are NOT intended to be parsed as valid XML
+ */
+function stringifyConverseChunkedMessage(chunks) {
+  const stringifiedChunks = chunks.map((chunk) => {
+    if ('text' in chunk) {
+      return chunk.text
+    } else if ('image' in chunk) {
+      return '<image>'
+    } else if ('document' in chunk) {
+      return `<document>${chunk.document.name ?? ''}</document>`
+    } else if ('toolUse' in chunk) {
+      return `<tool_use>${chunk.toolUse?.name ?? ''}</tool_use>`
+    } else if ('json' in chunk) {
+      return `<json>${JSON.stringify(chunk.json)}</json>`
+    } else if ('toolResult' in chunk) {
+      // Tool results can have their own chunks. For now we intentionally don't recurse in for non-text tool results
+      return `<tool_result>${
+          stringifyConverseChunkedMessage(
+            (chunk.toolResult.content ?? [])
+              .filter(subChunk => !('toolUse' in subChunk || 'toolResult' in subChunk))
+            )
+        }</tool_result>`
+    } else if ('guardContent' in chunk) {
+      return `<guard_content>${chunk.guardContent?.text ?? ''}</guard_content>`
+    }
+    return '<unknown_chunk>'
+  })
+  return stringifiedChunks.join('\n\n')
+}
+
 module.exports = {
-  stringifyClaudeChunkedMessage
+  stringifyClaudeChunkedMessage,
+  stringifyConverseChunkedMessage
 }

package/lib/shim/shim.js

@@ -2030,7 +2030,7 @@ function wrapStreamEmit({ stream, shim, segment, specEvent, shouldCreateSegment,
           const newContext = context.enterSegment({ segment: eventSegment })
           eventBoundEmit = shim.bindContext({ nodule: emit, full: true, context: newContext })
         }
-        eventSegment.addAttribute('count', ++emitCount)
+        if (eventSegment) eventSegment.addAttribute('count', ++emitCount)
         emitToCall = eventBoundEmit
       }
       if (evnt === 'end' || evnt === 'error') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "12.24.0",
+  "version": "12.25.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [