@arizeai/openinference-instrumentation-openai 4.3.2 → 4.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arizeai/openinference-instrumentation-openai",
-  "version": "4.3.2",
+  "version": "4.4.0",
   "private": false,
   "description": "OpenInference instrumentation for OpenAI",
   "keywords": [],
@@ -38,7 +38,7 @@
     "@opentelemetry/sdk-trace-node": "^1.25.1",
     "@opentelemetry/semantic-conventions": "^1.25.1",
     "@types/node": "^20.14.11",
-    "openai": "^6.7.0",
+    "openai": "^7.30.0",
     "typescript": "^7.0.2",
     "vitest": "^4.0.3",
     "zod": "^3.24.3"

package/src/decisionsAttributes.ts

@@ -0,0 +1,74 @@
+import type { Attributes } from "@opentelemetry/api";
+import type { Decision, DecisionCreateParams } from "openai/resources/decisions";
+
+import {
+  getDecisionAttributes,
+  getInputAttributes,
+  getOutputAttributes,
+  safelyJSONStringify,
+} from "@arizeai/openinference-core";
+import {
+  DecisionProvider,
+  DecisionSystem,
+  MimeType,
+} from "@arizeai/openinference-semantic-conventions";
+
+/**
+ * Builds the OpenInference attributes for a Decisions API request.
+ *
+ * Decision spans identify the model under `decision.*` rather than `llm.*`,
+ * and carry the raw request as JSON on `input.value` instead of input
+ * messages: the interesting part of a decision request is the set of typed
+ * questions and candidate answers, which has no message equivalent.
+ *
+ * @param body - The `decisions.create` request body.
+ * @returns `decision.system`, `decision.provider`, `decision.request.model_name`,
+ * `decision.model_name` and the input attributes.
+ * @see https://github.com/Arize-ai/openinference/blob/main/spec/decision_spans.md
+ */
+export function getDecisionsRequestAttributes(body: DecisionCreateParams): Attributes {
+  const input = safelyJSONStringify(body);
+  return {
+    ...getDecisionAttributes({
+      system: DecisionSystem.OPENAI,
+      provider: DecisionProvider.OPENAI,
+      requestModelName: body.model,
+    }),
+    ...(input != null ? getInputAttributes({ value: input, mimeType: MimeType.JSON }) : {}),
+  };
+}
+
+/**
+ * Builds the OpenInference attributes for a Decisions API response.
+ *
+ * Records the raw response as JSON on `output.value`, the model that served
+ * the decision as `decision.response.model_name` (and as `decision.model_name`,
+ * falling back to the requested model when the response omits it), and the
+ * reported usage as `decision.token_count.input` / `decision.token_count.output`.
+ *
+ * @param args - Attribute sources.
+ * @param args.response - The parsed `decisions.create` response.
+ * @param args.requestModelName - The model named in the request, used as the
+ * `decision.model_name` fallback.
+ * @returns The output and decision response attributes.
+ */
+export function getDecisionsResponseAttributes({
+  response,
+  requestModelName,
+}: {
+  response: Decision;
+  requestModelName?: string;
+}): Attributes {
+  const output = safelyJSONStringify(response);
+  return {
+    ...(output != null ? getOutputAttributes({ value: output, mimeType: MimeType.JSON }) : {}),
+    ...getDecisionAttributes({
+      requestModelName,
+      responseModelName: response.model,
+      tokenCount: {
+        input: response.usage?.input_tokens,
+        output: response.usage?.output_tokens,
+      },
+    }),
+  };
+}

package/src/instrumentation.ts

@@ -21,6 +21,7 @@ import type {
   ChatCompletionMessageParam,
 } from "openai/resources/chat/completions";
 import type { CompletionCreateParamsBase } from "openai/resources/completions";
+import type { Decision } from "openai/resources/decisions";
 import type {
   Response as ResponseType,
   ResponseCreateParamsBase,
@@ -38,6 +39,10 @@ import {
   SemanticConventions,
 } from "@arizeai/openinference-semantic-conventions";
 
+import {
+  getDecisionsRequestAttributes,
+  getDecisionsResponseAttributes,
+} from "./decisionsAttributes";
 import {
   consumeResponseStreamEvents,
   getResponsesInputMessagesAttributes,
@@ -590,6 +595,64 @@ export class OpenAIInstrumentation extends InstrumentationBase<typeof openai> {
       );
     }
 
+    // Patch decisions (if the patched module contains the Decisions interface, openai >= 7.30)
+    if (module.OpenAI.Decisions) {
+      type DecisionsCreateType = typeof module.OpenAI.Decisions.prototype.create;
+
+      this._wrap(
+        module.OpenAI.Decisions.prototype,
+        "create",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (original: DecisionsCreateType): any => {
+          return function patchedCreate(this: unknown, ...args: Parameters<DecisionsCreateType>) {
+            const body = args[0];
+            // A decision model scores caller-supplied answers rather than generating
+            // text, so this is a DECISION span with no llm.* attributes.
+            const span = instrumentation.oiTracer.startSpan(`OpenAI Decisions`, {
+              kind: SpanKind.INTERNAL,
+              attributes: {
+                [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.DECISION,
+                ...getDecisionsRequestAttributes(body),
+              },
+            });
+            const execContext = getExecContext(span);
+            const recordError = (error: unknown) => {
+              span.recordException(error instanceof Error ? error : String(error));
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+              });
+              span.end();
+            };
+            const execPromise = safeExecuteInTheMiddle(
+              () => {
+                return context.with(trace.setSpan(execContext, span), () => {
+                  return original.apply(this, args);
+                });
+              },
+              (error) => {
+                // Push the error to the span
+                if (error) {
+                  recordError(error);
+                }
+              },
+            );
+            const wrappedPromiseThen = (result: Decision) => {
+              span.setAttributes(
+                getDecisionsResponseAttributes({ response: result, requestModelName: body.model }),
+              );
+              span.setStatus({ code: SpanStatusCode.OK });
+              span.end();
+              return result;
+            };
+            observeRejection(execPromise, recordError);
+            const wrappedPromise = invokeMaybeAPIPromise(execPromise, wrappedPromiseThen);
+            return context.bind(execContext, wrappedPromise);
+          };
+        },
+      );
+    }
+
     _isOpenInferencePatched = true;
     _patchedModules.add(module.OpenAI);
     this.patchedModuleExports.set(module.OpenAI, module);
@@ -613,6 +676,12 @@ export class OpenAIInstrumentation extends InstrumentationBase<typeof openai> {
     this._unwrap(moduleExports.OpenAI.Chat.Completions.prototype, "create");
     this._unwrap(moduleExports.OpenAI.Completions.prototype, "create");
     this._unwrap(moduleExports.OpenAI.Embeddings.prototype, "create");
+    if (moduleExports.OpenAI.Responses) {
+      this._unwrap(moduleExports.OpenAI.Responses.prototype, "create");
+    }
+    if (moduleExports.OpenAI.Decisions) {
+      this._unwrap(moduleExports.OpenAI.Decisions.prototype, "create");
+    }
 
     // Keyed the same way patch() keys it, so a re-patch is possible after.
     _patchedModules.delete(moduleExports.OpenAI);
@@ -1037,6 +1106,27 @@ function isAPIPromise<T>(promise: unknown): promise is APIPromise<T> {
   return promise instanceof APIPromise;
 }
 
+/**
+ * Calls `onRejected` if the SDK call rejects, so the span can be ended with an
+ * error status.
+ *
+ * {@link invokeMaybeAPIPromise} only sees fulfilled values, so without this a
+ * failed request would leave its span open. For an APIPromise the rejection is
+ * observed through `asResponse()`, which settles with the underlying HTTP
+ * promise and never parses the body: parsing it here as well would consume the
+ * body before the caller reads it.
+ *
+ * @param promise - The value returned by the original SDK method
+ * @param onRejected - Called with the rejection reason
+ */
+function observeRejection(promise: unknown, onRejected: (error: unknown) => void): void {
+  if (isAPIPromise<unknown>(promise)) {
+    void promise.asResponse().then(undefined, onRejected);
+  } else if (promise instanceof Promise) {
+    void promise.then(undefined, onRejected);
+  }
+}
+
 /**
  * Invokes the thennable of a promise or an APIPromise.
  *

package/src/responsesAttributes.ts

@@ -20,7 +20,7 @@ import { getNumberProperty } from "./typeUtils";
  * @returns The attributes for the item
  */
 function getResponseItemAttributes(
-  item: Exclude<ResponseInputItem | ResponseOutputItem, { role: string }>,
+  item: Exclude<ResponseInputItem | ResponseOutputItem, { role: string; content: unknown }>,
   prefix = "",
 ): Attributes {
   const attributes: Attributes = {};
@@ -40,13 +40,14 @@ function getResponseItemAttributes(
     }
     case "function_call_output": {
       attributes[`${prefix}${SemanticConventions.MESSAGE_ROLE}`] = "tool";
-      attributes[`${prefix}${SemanticConventions.MESSAGE_TOOL_CALL_ID}`] = item.call_id;
+      attributes[`${prefix}${SemanticConventions.MESSAGE_TOOL_CALL_ID}`] =
+        item.call_id ?? undefined;
       if (typeof item.output === "string") {
         attributes[`${prefix}${SemanticConventions.MESSAGE_CONTENT}`] = item.output;
       } else {
         // TODO(2410): figure out how to serialize the list of tools
         attributes[`${prefix}${SemanticConventions.MESSAGE_CONTENT}`] =
-          safelyJSONStringify(item.output) || undefined;
+          safelyJSONStringify(item.output) ?? undefined;
       }
 
       break;
@@ -131,7 +132,9 @@ function getResponseItemMessageAttributes(
     typeof itemMessage === "string"
       ? ({ content: itemMessage, role: "user" } satisfies ResponseInputItem)
       : itemMessage;
-  if (!("role" in message)) {
+  // Items such as `additional_tools` carry a role but no content, and are
+  // handled with the other non-message items.
+  if (!("role" in message) || !("content" in message)) {
     return getResponseItemAttributes(message, prefix);
   }
   const role = message.role;

package/src/version.ts

@@ -1,2 +1,2 @@
 // this is an auto-generated file. see js/scripts/version-update.js
-export const VERSION = "4.3.2";
+export const VERSION = "4.4.0";