feat: Support openai.responses.create api (newrelic#3139)

Author: amychisholm03

lib/instrumentation/openai.js

@@ -23,6 +23,61 @@ const { DESTINATIONS } = require('../config/attribute-filter')
 
 let TRACKING_METRIC = OPENAI.TRACKING_PREFIX
 
+/**
+ * Parses the response from OpenAI and extracts the message content and role.
+ *
+ * @param {object} response The OpenAI SDK response object
+ * @returns {{ content: string, role: string }} the message object with fields `content` and `role`
+ */
+function getMessageFromResponse(response) {
+  let content
+  let role
+  if (response?.object === 'response') {
+    content = response?.output?.[0]?.content?.[0]?.text
+    role = response?.output?.[0]?.role
+  } else {
+    content = response?.choices?.[0]?.message?.content
+    role = response?.choices?.[0]?.message?.role
+  }
+
+  return { content, role }
+}
+
+/**
+ * Parses all messages from the OpenAI request object.
+ *
+ * @param {object} request The OpenAI SDK request object
+ * @param {Shim} shim instance of shim
+ * @returns {Array<object>} an array of message objects with fields `content` and `role`
+ */
+function getMessagesFromRequest(request, shim) {
+  // There are a few different ways to pass messages to OpenAI SDK.
+  //
+  // For langchain and `chat.completions.create`, messages are passed
+  // as an array of objects with `content` and `role` properties
+  // to the `messages` field of the request.
+  //
+  // For `responses.create`, messages are passed as an array of objects
+  // with `content` and `role` properties OR as a single string (implied
+  // to be a user message) to the `input` field of the request.
+  let messages = []
+
+  if (Array.isArray(request?.input)) {
+    // Handle array of input messages
+    messages = request.input.filter(msg => msg?.content && msg?.role)
+  } else if (typeof request?.input === 'string') {
+    // Handle single string input as a user message
+    messages = [{ content: request.input, role: 'user' }]
+  } else if (Array.isArray(request?.messages)) {
+    // Handle array of messages
+    messages = request.messages.filter(msg => msg?.content && msg?.role)
+  } else {
+    shim.logger.warn('No valid messages found in OpenAI request object.')
+  }
+
+  return messages
+}
+
 /**
  * Checks if we should skip instrumentation.
  * Currently, it checks if `ai_monitoring.enabled` is true
@@ -145,8 +200,13 @@ function recordChatCompletionMessages({
     withError: err != null
   })
 
-  // Only take the first response message and append to input messages
-  const messages = [...request.messages, response?.choices?.[0]?.message]
+  // Note: langchain still expects a message event even
+  // when the response is empty, so no filtering here
+  const messages = [
+    ...getMessagesFromRequest(request, shim),
+    getMessageFromResponse(response)
+  ]
+
   messages.forEach((message, index) => {
     const completionMsg = new LlmChatCompletionMessage({
       agent,
@@ -218,6 +278,7 @@ function instrumentStream({ agent, shim, request, response, segment, transaction
         throw err
       } finally {
         chunk.choices[0].message = { role, content }
+
         // update segment duration since we want to extend the time it took to
         // handle the stream
         segment.touch()
@@ -275,7 +336,6 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
 
   // Instruments chat completion creation
   // and creates the LLM events
-  // **Note**: Currently only for promises. streams will come later
   shim.record(
     openaiClient.Chat.Completions.prototype,
     'create',
@@ -312,6 +372,37 @@ module.exports = function initialize(agent, openai, moduleName, shim) {
     }
   )
 
+  // New API introduced in openai@5.0.0
+  // Also instruments chat completion creation
+  // and creates the LLM events
+  if (semver.gte(shim.pkgVersion, '5.0.0')) {
+    shim.record(openaiClient.Responses.prototype, 'create', function wrapCreate(shim, create, name, args) {
+      const [request] = args
+      if (request.stream) {
+        shim.logger.warn('Streaming is not supported for responses.create yet.')
+        return
+      }
+
+      return new RecorderSpec({
+        name: OPENAI.COMPLETION,
+        promise: true,
+        after({ error: err, result: response, segment, transaction }) {
+          recordChatCompletionMessages({
+            agent,
+            shim,
+            segment,
+            transaction,
+            request,
+            response,
+            err
+          })
+
+          addLlmMeta({ agent, transaction })
+        }
+      })
+    })
+  }
+
   // Instruments embedding creation
   // and creates LlmEmbedding event
   shim.record(

lib/llm-events/openai/chat-completion-message.js

@@ -13,7 +13,7 @@ module.exports = class LlmChatCompletionMessage extends LlmEvent {
     request = {},
     response = {},
     index = 0,
-    message,
+    message = { content: undefined, role: undefined },
     completionId,
     transaction
   }) {
@@ -22,21 +22,33 @@ module.exports = class LlmChatCompletionMessage extends LlmEvent {
     this.role = message?.role
     this.sequence = index
     this.completion_id = completionId
-    this.is_response = response?.choices?.[0]?.message?.content === message?.content
 
+    // Check if the given message is from the response.
+    // The response object differs based on the API called.
+    // If it's `responses.create`, we check against `response.output`.
+    // If it's `chat.completions.create` or langchain, we check against `response.choices`.
+    if (response?.object === 'response') {
+      this.is_response = message.content === response?.output?.[0]?.content?.[0]?.text
+    } else {
+      this.is_response = message.content === response?.choices?.[0]?.message?.content
+    }
+
+    // Assign content to the event.
+    const content = message?.content
     if (agent.config.ai_monitoring.record_content.enabled === true) {
-      this.content = message?.content
+      this.content = content
     }
 
+    // Calculate token count if the callback is available.
     const tokenCB = agent.llm?.tokenCountCallback
     if (typeof tokenCB !== 'function') {
       return
     }
 
     if (this.is_response) {
-      this.token_count = tokenCB(this['response.model'], message?.content)
+      this.token_count = tokenCB(this['response.model'], content)
     } else {
-      this.token_count = tokenCB(request.model || request.engine, message?.content)
+      this.token_count = tokenCB(request.model || request.engine, content)
     }
   }
 }

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

@@ -10,9 +10,19 @@ module.exports = class LlmChatCompletionSummary extends LlmEvent {
   constructor({ agent, segment, request = {}, response = {}, withError = false, transaction }) {
     super({ agent, segment, request, response, responseAttrs: true, transaction })
     this.error = withError
-    this['request.max_tokens'] = request.max_tokens
+    this['request.max_tokens'] = request.max_tokens ?? request.max_output_tokens
     this['request.temperature'] = request.temperature
-    this['response.number_of_messages'] = request?.messages?.length + response?.choices?.length
-    this['response.choices.finish_reason'] = response?.choices?.[0]?.finish_reason
+
+    if (response?.object === 'response') {
+      // `responses.create` 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
+      this['response.choices.finish_reason'] = response?.status
+    } else {
+      // `chat.completions.create` logic
+      this['response.number_of_messages'] = request?.messages?.length + response?.choices?.length
+      this['response.choices.finish_reason'] = response?.choices?.[0]?.finish_reason
+    }
   }
 }