dd-trace 5.104.0 → 5.106.0

package/packages/datadog-instrumentations/src/helpers/ai-messages.js

@@ -1,5 +1,53 @@
 'use strict'
 
+/**
+ * Returns the value as a string, JSON-stringifying it when it is not already a string.
+ * Returns the value unchanged when it is `null` or `undefined`.
+ *
+ * @param {unknown} value
+ * @returns {string|undefined|null}
+ */
+function stringifyIfNeeded (value) {
+  if (value == null) return value
+  return typeof value === 'string' ? value : JSON.stringify(value)
+}
+
+const FILE_FALLBACK = '[file]'
+const IMAGE_FALLBACK = '[image]'
+
+const OPENAI_RESPONSE_TOOL_CALL_TYPES = new Set([
+  'apply_patch_call',
+  'code_interpreter_call',
+  'computer_call',
+  'custom_tool_call',
+  'file_search_call',
+  'function_call',
+  'image_generation_call',
+  'local_shell_call',
+  'mcp_call',
+  'shell_call',
+  'web_search_call',
+])
+
+const OPENAI_RESPONSE_TOOL_OUTPUT_TYPES = new Set([
+  'apply_patch_call_output',
+  'computer_call_output',
+  'custom_tool_call_output',
+  'function_call_output',
+  'local_shell_call_output',
+  'shell_call_output',
+])
+
+/**
+ * Returns a stringified value, falling back to an empty string for absent values.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+function stringifyOrEmpty (value) {
+  return stringifyIfNeeded(value) ?? ''
+}
+
 /**
  * Converts a LanguageModelV2FilePart with an image mediaType to an AI guard style image_url content part.
  *
@@ -79,12 +127,11 @@ function convertVercelPromptToMessages (prompt) {
           if (part.type === 'text') {
             textParts.push(part.text)
           } else if (part.type === 'tool-call') {
-            const args = part.args ?? part.input
             toolCalls.push({
               id: part.toolCallId,
               function: {
                 name: part.toolName,
-                arguments: typeof args === 'string' ? args : JSON.stringify(args),
+                arguments: stringifyIfNeeded(part.args ?? part.input),
               },
             })
           }
@@ -103,11 +150,10 @@ function convertVercelPromptToMessages (prompt) {
 
         for (const part of msg.content) {
           if (part.type === 'tool-result') {
-            const result = part.result ?? part.output
             messages.push({
               role: 'tool',
               tool_call_id: part.toolCallId,
-              content: typeof result === 'string' ? result : JSON.stringify(result),
+              content: stringifyIfNeeded(part.result ?? part.output),
             })
           }
         }
@@ -118,6 +164,58 @@ function convertVercelPromptToMessages (prompt) {
   return messages
 }
 
+/**
+ * Converts OpenAI chat-completions messages to the message format expected by AI Guard.
+ *
+ * Modern `tool_calls` messages already match the expected shape. Deprecated chat
+ * completions `function_call` and `function` role messages are normalized to the
+ * equivalent tool-call shape so AI Guard can classify them as tool interactions.
+ *
+ * @param {Array<object>} messages
+ * @returns {Array<object>|undefined}
+ */
+function normalizeOpenAIChatMessages (messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return
+
+  const normalizedMessages = []
+  for (const message of messages) {
+    const normalized = normalizeOpenAIChatMessage(message)
+    if (normalized) normalizedMessages.push(normalized)
+  }
+  return normalizedMessages.length ? normalizedMessages : undefined
+}
+
+/**
+ * Converts one OpenAI chat-completions message to AI Guard's expected shape.
+ *
+ * @param {object} message
+ * @returns {object|undefined}
+ */
+function normalizeOpenAIChatMessage (message) {
+  if (!message || typeof message !== 'object') return
+
+  if (message.role === 'function') {
+    return {
+      role: 'tool',
+      tool_call_id: message.tool_call_id ?? message.name,
+      content: stringifyOrEmpty(message.content),
+    }
+  }
+
+  if (!message.function_call) return message
+
+  const { function_call: functionCall, ...normalized } = message
+  const name = functionCall.name
+  normalized.tool_calls ??= [{
+    id: message.tool_call_id ?? name,
+    function: {
+      name,
+      arguments: stringifyOrEmpty(functionCall.arguments),
+    },
+  }]
+  return normalized
+}
+
 /**
  * Converts LLM output tool calls to AI guard style message format.
  *
@@ -130,16 +228,13 @@ function buildToolCallOutputMessages (inputMessages, toolCalls) {
     ...inputMessages,
     {
       role: 'assistant',
-      tool_calls: toolCalls.map(tc => {
-        const args = tc.args ?? tc.input
-        return {
-          id: tc.toolCallId,
-          function: {
-            name: tc.toolName,
-            arguments: typeof args === 'string' ? args : JSON.stringify(args),
-          },
-        }
-      }),
+      tool_calls: toolCalls.map(tc => ({
+        id: tc.toolCallId,
+        function: {
+          name: tc.toolName,
+          arguments: stringifyIfNeeded(tc.args ?? tc.input),
+        },
+      })),
     },
   ]
 }
@@ -173,10 +268,223 @@ function buildOutputMessages (inputMessages, content) {
   return inputMessages
 }
 
+/**
+ * Converts OpenAI Responses API input/output items to OpenAI chat-style messages.
+ *
+ * @param {string|Array<object>|undefined} items
+ * @param {string} defaultRole
+ * @returns {Array<object>}
+ */
+function convertOpenAIResponseItemsToMessages (items, defaultRole) {
+  if (typeof items === 'string') return [{ role: defaultRole, content: items }]
+  if (!Array.isArray(items)) return []
+
+  const messages = []
+  for (const item of items) {
+    const converted = openAIResponseItemToMessage(item, defaultRole)
+    if (Array.isArray(converted)) {
+      for (const message of converted) messages.push(message)
+    } else if (converted) {
+      messages.push(converted)
+    }
+  }
+  return messages
+}
+
+/**
+ * Converts OpenAI reusable prompt variables to user messages for AI Guard.
+ *
+ * The reusable prompt template body is not available on the request, but its
+ * variables are user/application-provided content that OpenAI substitutes into
+ * the prompt. Screening them closes prompt-only `responses.create({ prompt })`
+ * calls and prompt variables used alongside `input`.
+ *
+ * @param {{variables?: Record<string, string|object>|null}|undefined|null} prompt
+ * @returns {Array<object>}
+ */
+function convertOpenAIResponsePromptToMessages (prompt) {
+  const variables = prompt?.variables
+  if (!variables || typeof variables !== 'object') return []
+
+  const messages = []
+  for (const value of Object.values(variables)) {
+    const content = openAIResponsePromptVariableToMessageContent(value)
+    if (content != null) messages.push({ role: 'user', content })
+  }
+  return messages
+}
+
+/**
+ * Converts one OpenAI reusable prompt variable value to message content.
+ *
+ * Routes every variable through `openAIResponseContentToMessageContent` so the
+ * result follows the same string-when-text-only / array-when-multimodal shape
+ * convention used elsewhere in this file. Media variables that produce no
+ * usable content (e.g. an `input_image` with no URL or `file_id`) fall back to
+ * a stable text marker so AI Guard still observes that a media variable was
+ * attached.
+ *
+ * @param {string|object} value
+ * @returns {string|Array<{type: string, text?: string, image_url?: {url: string}}>|undefined}
+ */
+function openAIResponsePromptVariableToMessageContent (value) {
+  let part
+  if (typeof value === 'string') {
+    part = { type: 'input_text', text: value }
+  } else if (value && typeof value === 'object') {
+    part = value
+  } else {
+    return
+  }
+
+  const content = openAIResponseContentToMessageContent([part])
+  if (content != null) return content
+  if (part.type === 'input_image') return IMAGE_FALLBACK
+}
+
+/**
+ * Converts one OpenAI Responses API item to an OpenAI chat-style message.
+ *
+ * @param {object} item
+ * @param {string} defaultRole
+ * @returns {object|Array<object>|undefined}
+ */
+function openAIResponseItemToMessage (item, defaultRole) {
+  if (!item || typeof item !== 'object') return
+  const type = item.type ?? 'message'
+
+  if (type === 'message') {
+    const content = openAIResponseContentToMessageContent(item.content)
+    if (content != null) return { role: item.role || defaultRole, content }
+  } else if (OPENAI_RESPONSE_TOOL_CALL_TYPES.has(type)) {
+    return openAIResponseToolCallToMessages(item)
+  } else if (OPENAI_RESPONSE_TOOL_OUTPUT_TYPES.has(type)) {
+    return openAIResponseToolOutputToMessage(item)
+  }
+}
+
+/**
+ * Converts a Responses API tool-call item to one or more chat-style messages.
+ *
+ * Most tool-call items represent only the assistant's tool request. MCP and
+ * image-generation items can also carry tool output on the same item, so include
+ * a linked tool message when output-like fields are present.
+ *
+ * @param {object} item
+ * @returns {object|Array<object>}
+ */
+function openAIResponseToolCallToMessages (item) {
+  const toolCallId = item.call_id ?? item.id ?? item.name ?? item.type
+  const message = {
+    role: 'assistant',
+    tool_calls: [{
+      id: toolCallId,
+      function: {
+        name: item.name ?? item.server_label ?? item.type,
+        arguments: stringifyOrEmpty(item.arguments ?? item.input ?? item.action),
+      },
+    }],
+  }
+
+  if (item.output == null && item.result == null && item.error == null) return message
+  return [message, openAIResponseToolOutputToMessage(item)]
+}
+
+/**
+ * Converts a Responses API tool-output item to a chat-style tool message.
+ *
+ * @param {object} item
+ * @returns {object}
+ */
+function openAIResponseToolOutputToMessage (item) {
+  return {
+    role: 'tool',
+    tool_call_id: item.call_id ?? item.id,
+    content: openAIResponseOutputValueToMessageContent(item.output ?? item.result ?? item.error),
+  }
+}
+
+/**
+ * Converts Responses API tool output to message content.
+ *
+ * @param {unknown} output
+ * @returns {string|Array<{type: string, text?: string, image_url?: {url: string}}>}
+ */
+function openAIResponseOutputValueToMessageContent (output) {
+  const content = openAIResponseContentToMessageContent(output)
+  return content ?? stringifyOrEmpty(output)
+}
+
+/**
+ * Converts OpenAI Responses API content to OpenAI chat-style message content.
+ *
+ * @param {string|Array<string|{type?: string, text?: string, refusal?: string,
+ *   image_url?: string|{url?: string}, file_id?: string, file_url?: string,
+ *   filename?: string}>|undefined} content
+ * @returns {string|Array<{type: string, text?: string, image_url?: {url: string}}>|undefined}
+ */
+function openAIResponseContentToMessageContent (content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return
+
+  const parts = []
+  let hasImages = false
+
+  for (const part of content) {
+    if (!part) continue
+    if (typeof part === 'string') {
+      parts.push({ type: 'text', text: part })
+    } else if ((part.type === 'input_text' || part.type === 'output_text' || part.type === 'text') &&
+      typeof part.text === 'string') {
+      parts.push({ type: 'text', text: part.text })
+    } else if (part.type === 'refusal' && typeof part.refusal === 'string') {
+      parts.push({ type: 'text', text: part.refusal })
+    } else if (part.type === 'input_image' || part.type === 'image_url') {
+      const image = openAIResponseImageContentPart(part)
+      if (image) {
+        hasImages = true
+        parts.push(image)
+      }
+    } else if (part.type === 'input_file') {
+      parts.push({ type: 'text', text: openAIResponseFileContentPart(part) })
+    }
+  }
+
+  if (!parts.length) return
+  if (hasImages) return parts
+  return parts.map(part => part.text).join('\n')
+}
+
+/**
+ * Converts an OpenAI image content part to AI Guard image_url content.
+ *
+ * @param {{image_url?: string|{url?: string}, file_id?: string, url?: string}} part
+ * @returns {{type: 'image_url', image_url: {url: string}}|undefined}
+ */
+function openAIResponseImageContentPart (part) {
+  const url = typeof part.image_url === 'string' ? part.image_url : part.image_url?.url ?? part.url
+  if (url) return { type: 'image_url', image_url: { url } }
+  if (part.file_id) return { type: 'image_url', image_url: { url: part.file_id } }
+}
+
+/**
+ * Extracts a stable text marker from an OpenAI file content part.
+ *
+ * @param {{file_id?: string|null, file_url?: string, filename?: string, file_data?: string}} part
+ * @returns {string}
+ */
+function openAIResponseFileContentPart (part) {
+  return part.file_id ?? part.file_url ?? part.filename ?? FILE_FALLBACK
+}
+
 module.exports = {
   convertVercelPromptToMessages,
   convertFilePartToImageUrl,
+  normalizeOpenAIChatMessages,
   buildToolCallOutputMessages,
   buildTextOutputMessages,
   buildOutputMessages,
+  convertOpenAIResponseItemsToMessages,
+  convertOpenAIResponsePromptToMessages,
+  openAIResponseContentToMessageContent,
 }

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -5,6 +5,7 @@ module.exports = {
   child_process: () => require('../child_process'),
   crypto: () => require('../crypto'),
   dns: () => require('../dns'),
+  'dns/promises': () => require('../dns'),
   fs: { serverless: false, fn: () => require('../fs') },
   http: () => require('../http'),
   http2: () => require('../http2'),
@@ -21,6 +22,7 @@ module.exports = {
   '@modelcontextprotocol/sdk': () => require('../modelcontextprotocol-sdk'),
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
+  '@azure/cosmos': { esmFirst: true, fn: () => require('../azure-cosmos') },
   '@azure/event-hubs': () => require('../azure-event-hubs'),
   '@azure/functions': () => require('../azure-functions'),
   'durable-functions': () => require('../azure-durable-functions'),
@@ -48,6 +50,7 @@ module.exports = {
   '@prisma/client': { esmFirst: true, fn: () => require('../prisma') },
   './runtime/library.js': () => require('../prisma'),
   '@redis/client': () => require('../redis'),
+  '@smithy/core': () => require('../aws-sdk'),
   '@smithy/smithy-client': () => require('../aws-sdk'),
   '@vitest/runner': { esmFirst: true, fn: () => require('../vitest') },
   aerospike: () => require('../aerospike'),
@@ -111,6 +114,7 @@ module.exports = {
   multer: () => require('../multer'),
   mysql: () => require('../mysql'),
   mysql2: () => require('../mysql2'),
+  '@nats-io/nats-core': () => require('../nats'),
   next: () => require('../next'),
   'node-serialize': () => require('../node-serialize'),
   nyc: () => require('../nyc'),

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -58,7 +58,8 @@ exports.getHooks = function getHooks (names) {
  * @param {string} [args.file] path to file within package to instrument. Defaults to 'index.js'.
  * @param {string} [args.filePattern] pattern to match files within package to instrument
  * @param {boolean} [args.patchDefault] whether to patch the default export. Defaults to true.
- * @param {(moduleExports: unknown, version: string, isIitm?: boolean) => unknown} [hook] Patches module exports
+ * @param {(moduleExports: unknown, version: string, isIitm?: boolean, hookMeta?: object) => unknown} [hook]
+ * Patches module exports
  */
 exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {
   if (!instrumentations[name]) {

package/packages/datadog-instrumentations/src/helpers/openai-ai-guard.js

@@ -0,0 +1,269 @@
+'use strict'
+
+const dc = require('dc-polyfill')
+const shimmer = require('../../../datadog-shimmer')
+const {
+  convertOpenAIResponseItemsToMessages,
+  convertOpenAIResponsePromptToMessages,
+  normalizeOpenAIChatMessages,
+} = require('./ai-messages')
+
+// TODO: this channel name is incorrect, instrumentations publish with THEIR name, not with their subscribers names.
+const aiguardChannel = dc.channel('dd-trace:ai:aiguard')
+
+/**
+ * @typedef {object} ResourceHandler
+ * @property {(callArgs: object) => (Array<object>|undefined)} getInputMessages
+ * @property {(body: object) => Array<object>} getOutputMessages
+ * @property {(inputMessages: Array<object>, outputMessages: Array<object>) => Promise<unknown>}
+ *   publishOutputEvaluation
+ */
+
+/**
+ * @typedef {object} Guard
+ * @property {ResourceHandler} handler
+ * @property {Array<object>} inputMessages
+ * @property {() => Promise<void>} getInputEval
+ */
+
+/**
+ * Publishes already-converted AI-style messages to the AI Guard evaluation channel.
+ *
+ * @param {Array<object>} messages - AI-style messages to evaluate.
+ * @returns {Promise<void>}
+ */
+function publishEvaluation (messages) {
+  return new Promise((resolve, reject) => {
+    aiguardChannel.publish({ messages, integration: 'openai', resolve, reject })
+  })
+}
+
+/**
+ * Extracts OpenAI input messages from a `chat.completions.create` call.
+ *
+ * @param {object} callArgs - First argument passed to the wrapped method
+ * @returns {Array<object>|undefined}
+ */
+function getChatCompletionsInputMessages (callArgs) {
+  return normalizeOpenAIChatMessages(callArgs?.messages)
+}
+
+/**
+ * Extracts OpenAI output messages from a `chat.completions.create` parsed body.
+ * Includes any choice whose message carries content (including empty string),
+ * `tool_calls`, a `refusal` field, or the deprecated `function_call` field. GPT-4o
+ * emits `{content: null, refusal: "..."}` on policy refusals, and pre-tool-call
+ * SDK paths still produce `function_call`-only output — AI Guard must still see them.
+ *
+ * @param {object} body - Parsed response body
+ * @returns {Array<object>}
+ */
+function getChatCompletionsOutputMessages (body) {
+  const eligible = []
+  const choices = Array.isArray(body?.choices) ? body.choices : []
+  for (const choice of choices) {
+    const message = choice?.message
+    if (
+      message?.content != null ||
+      message?.tool_calls?.length ||
+      message?.refusal != null ||
+      message?.function_call != null
+    ) {
+      eligible.push(message)
+    }
+  }
+  return normalizeOpenAIChatMessages(eligible) ?? []
+}
+
+/**
+ * Publishes AI Guard After Model evaluation for `chat.completions` output.
+ *
+ * Chat completions may return multiple choices when `n > 1`. Screen every choice
+ * concurrently so any unsafe assistant output rejects `.parse()`, regardless of
+ * which choice the caller ends up using.
+ *
+ * @param {Array<object>} inputMessages
+ * @param {Array<object>} outputMessages - One entry per choice
+ * @returns {Promise<Array<void>>}
+ */
+function publishChatCompletionsOutputEvaluation (inputMessages, outputMessages) {
+  const evals = []
+  for (const message of outputMessages) {
+    evals.push(publishEvaluation([...inputMessages, message]))
+  }
+  return Promise.all(evals)
+}
+
+/**
+ * Extracts OpenAI input messages from a `responses.create` call. The `instructions`
+ * field is treated as a developer prompt — it directly steers model behavior and the
+ * LLMObs OpenAI plugin already surfaces it as one — so AI Guard must screen it too.
+ *
+ * AI Guard `/evaluate` accepts a single leading system/developer message; if the
+ * caller's `input` already begins with one, prepend the `instructions` text to its
+ * content rather than emit a second developer turn.
+ *
+ * @param {object} callArgs - First argument passed to the wrapped method
+ * @returns {Array<object>|undefined}
+ */
+function getResponsesInputMessages (callArgs) {
+  const messages = [
+    ...convertOpenAIResponseItemsToMessages(callArgs?.input, 'user'),
+    ...convertOpenAIResponsePromptToMessages(callArgs?.prompt),
+  ]
+
+  const instructions = typeof callArgs?.instructions === 'string' && callArgs.instructions.length
+    ? callArgs.instructions
+    : null
+  if (!instructions) return messages.length ? messages : undefined
+
+  const first = messages[0]
+  if (first && (first.role === 'developer' || first.role === 'system')) {
+    const merged = { role: 'developer', content: mergeInstructionsWithContent(instructions, first.content) }
+    return [merged, ...messages.slice(1)]
+  }
+  return [{ role: 'developer', content: instructions }, ...messages]
+}
+
+/**
+ * Merges Responses API instructions with an existing leading developer/system content value.
+ *
+ * @param {string} instructions
+ * @param {string|Array<object>|undefined} content
+ * @returns {string|Array<object>}
+ */
+function mergeInstructionsWithContent (instructions, content) {
+  if (Array.isArray(content)) return [{ type: 'text', text: instructions }, ...content]
+  if (typeof content === 'string' && content.length) return `${instructions}\n\n${content}`
+  return instructions
+}
+
+/**
+ * Extracts OpenAI output messages from a `responses.create` parsed body.
+ *
+ * @param {object} body - Parsed response body
+ * @returns {Array<object>}
+ */
+function getResponsesOutputMessages (body) {
+  return convertOpenAIResponseItemsToMessages(body?.output, 'assistant')
+}
+
+/**
+ * Publishes AI Guard After Model evaluation for `responses` output.
+ *
+ * The Responses API returns a single conversation turn whose `output` items form one
+ * coherent message (reasoning steps + final assistant message + tool calls + ...);
+ * they are screened together as a single evaluation.
+ *
+ * @param {Array<object>} inputMessages
+ * @param {Array<object>} outputMessages
+ * @returns {Promise<void>}
+ */
+function publishResponsesOutputEvaluation (inputMessages, outputMessages) {
+  return publishEvaluation([...inputMessages, ...outputMessages])
+}
+
+/**
+ * Per-resource handlers describing how AI Guard reads inputs and screens outputs for
+ * each LLM-prompt-accepting OpenAI endpoint. The keys also serve as the set of
+ * resources eligible for AI Guard evaluation.
+ *
+ * @type {Record<string, ResourceHandler>}
+ */
+const RESOURCE_HANDLERS = {
+  'chat.completions': {
+    getInputMessages: getChatCompletionsInputMessages,
+    getOutputMessages: getChatCompletionsOutputMessages,
+    publishOutputEvaluation: publishChatCompletionsOutputEvaluation,
+  },
+  responses: {
+    getInputMessages: getResponsesInputMessages,
+    getOutputMessages: getResponsesOutputMessages,
+    publishOutputEvaluation: publishResponsesOutputEvaluation,
+  },
+}
+
+/**
+ * Reports whether the AI Guard channel has subscribers. The OpenAI instrumentation
+ * uses this to decide whether to take the AI Guard path at all.
+ *
+ * @returns {boolean}
+ */
+function hasSubscribers () {
+  return aiguardChannel.hasSubscribers
+}
+
+/**
+ * Builds a guard handle when AI Guard is enabled and applicable to this call. The
+ * handle binds the per-resource handler so downstream functions never re-dispatch
+ * on `baseResource`. Returns null when AI Guard does not apply (no subscribers,
+ * non-eligible resource, streaming, or no input messages).
+ *
+ * @param {string} baseResource - e.g. `'chat.completions'` or `'responses'`
+ * @param {object} callArgs - First argument passed to the wrapped OpenAI method
+ * @param {boolean} stream - Whether the caller asked for a streamed response
+ * @returns {Guard|null}
+ */
+function createGuard (baseResource, callArgs, stream) {
+  // Streaming AI Guard support lands in a follow-up PR. For now, provider-level AI
+  // Guard only evaluates non-streaming responses.
+  if (stream || !aiguardChannel.hasSubscribers) return null
+  const handler = RESOURCE_HANDLERS[baseResource]
+  if (!handler) return null
+
+  const inputMessages = handler.getInputMessages(callArgs)
+  if (!inputMessages) return null
+
+  let inputEvalPromise
+  const getInputEval = () => (inputEvalPromise ??= publishEvaluation(inputMessages))
+  return { handler, inputMessages, getInputEval }
+}
+
+/**
+ * Wraps `apiProm.asResponse` so callers that consume the raw `Response` object still
+ * receive the Before Model verdict. After Model evaluation is not performed on this
+ * path because the response body has not been parsed.
+ *
+ * @param {object} apiProm - APIPromise returned from the OpenAI SDK method
+ * @param {Guard} guard
+ */
+function wrapAsResponse (apiProm, guard) {
+  if (typeof apiProm.asResponse !== 'function') return
+  shimmer.wrap(apiProm, 'asResponse', origAsResponse => function (...args) {
+    const responsePromise = origAsResponse.apply(this, args)
+    return Promise.all([guard.getInputEval(), responsePromise]).then(([, response]) => response)
+  })
+}
+
+/**
+ * Gates the parsed-body promise on Before Model evaluation. Resolves to the SDK's
+ * result only once the Before Model verdict is in.
+ *
+ * @param {Promise<unknown>} parsedPromise
+ * @param {Guard} guard
+ * @returns {Promise<unknown>}
+ */
+function gateParse (parsedPromise, guard) {
+  return Promise.all([guard.getInputEval(), parsedPromise]).then(([, result]) => result)
+}
+
+/**
+ * Runs After Model evaluation against the response body.
+ *
+ * @param {Guard} guard
+ * @param {object} body - Parsed OpenAI response body
+ * @returns {Promise<unknown>}
+ */
+function evaluateOutput (guard, body) {
+  const outputMessages = guard.handler.getOutputMessages(body)
+  if (!outputMessages.length) return Promise.resolve()
+  return guard.handler.publishOutputEvaluation(guard.inputMessages, outputMessages)
+}
+
+module.exports = {
+  hasSubscribers,
+  createGuard,
+  wrapAsResponse,
+  gateParse,
+  evaluateOutput,
+}