@arizeai/openinference-instrumentation-openai 1.1.1 → 2.0.0

package/dist/esm/instrumentation.js

@@ -1,123 +1,16 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 import { InstrumentationBase, InstrumentationNodeModuleDefinition, safeExecuteInTheMiddle, } from "@opentelemetry/instrumentation";
 import { diag, context, trace, SpanKind, SpanStatusCode, } from "@opentelemetry/api";
-import { VERSION } from "./version";
+import { VERSION } from "./version.js";
 import { SemanticConventions, OpenInferenceSpanKind, MimeType, LLMSystem, LLMProvider, } from "@arizeai/openinference-semantic-conventions";
-import { assertUnreachable, isString } from "./typeUtils";
+import { assertUnreachable, isString } from "./typeUtils.js";
 import { isTracingSuppressed } from "@opentelemetry/core";
 import { OITracer, safelyJSONStringify, } from "@arizeai/openinference-core";
-var MODULE_NAME = "openai";
+const MODULE_NAME = "openai";
 /**
  * Flag to check if the openai module has been patched
  * Note: This is a fallback in case the module is made immutable (e.x. Deno, webpack, etc.)
  */
-var _isOpenInferencePatched = false;
+let _isOpenInferencePatched = false;
 /**
  * function to check if instrumentation is enabled / disabled
  */
@@ -130,9 +23,9 @@ export function isPatched() {
  * @param span
  */
 function getExecContext(span) {
-    var activeContext = context.active();
-    var suppressTracing = isTracingSuppressed(activeContext);
-    var execContext = suppressTracing
+    const activeContext = context.active();
+    const suppressTracing = isTracingSuppressed(activeContext);
+    const execContext = suppressTracing
         ? trace.setSpan(context.active(), span)
         : activeContext;
     // Drop the span from the context
@@ -146,59 +39,60 @@ function getExecContext(span) {
  * @param instrumentationConfig The config for the instrumentation @see {@link InstrumentationConfig}
  * @param traceConfig The OpenInference trace configuration. Can be used to mask or redact sensitive information on spans. @see {@link TraceConfigOptions}
  */
-var OpenAIInstrumentation = /** @class */ (function (_super) {
-    __extends(OpenAIInstrumentation, _super);
-    function OpenAIInstrumentation(_a) {
-        var _b = _a === void 0 ? {} : _a, instrumentationConfig = _b.instrumentationConfig, traceConfig = _b.traceConfig;
-        var _this = _super.call(this, "@arizeai/openinference-instrumentation-openai", VERSION, Object.assign({}, instrumentationConfig)) || this;
-        _this.oiTracer = new OITracer({ tracer: _this.tracer, traceConfig: traceConfig });
-        return _this;
+export class OpenAIInstrumentation extends InstrumentationBase {
+    constructor({ instrumentationConfig, traceConfig, } = {}) {
+        super("@arizeai/openinference-instrumentation-openai", VERSION, Object.assign({}, instrumentationConfig));
+        this.oiTracer = new OITracer({ tracer: this.tracer, traceConfig });
     }
-    OpenAIInstrumentation.prototype.init = function () {
-        var module = new InstrumentationNodeModuleDefinition("openai", ["^4.0.0"], this.patch.bind(this), this.unpatch.bind(this));
+    init() {
+        const module = new InstrumentationNodeModuleDefinition("openai", ["^4.0.0"], this.patch.bind(this), this.unpatch.bind(this));
         return module;
-    };
+    }
     /**
      * Manually instruments the OpenAI module. This is needed when the module is not loaded via require (commonjs)
      * @param {openai} module
      */
-    OpenAIInstrumentation.prototype.manuallyInstrument = function (module) {
-        diag.debug("Manually instrumenting ".concat(MODULE_NAME));
+    manuallyInstrument(module) {
+        diag.debug(`Manually instrumenting ${MODULE_NAME}`);
         this.patch(module);
-    };
+    }
     /**
      * Patches the OpenAI module
      */
-    OpenAIInstrumentation.prototype.patch = function (module, moduleVersion) {
-        diag.debug("Applying patch for ".concat(MODULE_NAME, "@").concat(moduleVersion));
-        if ((module === null || module === void 0 ? void 0 : module.openInferencePatched) || _isOpenInferencePatched) {
+    patch(module, moduleVersion) {
+        diag.debug(`Applying patch for ${MODULE_NAME}@${moduleVersion}`);
+        if (module?.openInferencePatched || _isOpenInferencePatched) {
             return module;
         }
         // eslint-disable-next-line @typescript-eslint/no-this-alias
-        var instrumentation = this;
+        const instrumentation = this;
         // Patch create chat completions
         this._wrap(module.OpenAI.Chat.Completions.prototype, "create", 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        function (original) {
-            return function patchedCreate() {
-                var _a;
-                var _this = this;
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var body = args[0];
-                var _messages = body.messages, invocationParameters = __rest(body, ["messages"]);
-                var span = instrumentation.oiTracer.startSpan("OpenAI Chat Completions", {
+        (original) => {
+            return function patchedCreate(...args) {
+                const body = args[0];
+                const { messages: _messages, ...invocationParameters } = body;
+                const span = instrumentation.oiTracer.startSpan(`OpenAI Chat Completions`, {
                     kind: SpanKind.INTERNAL,
-                    attributes: __assign(__assign((_a = {}, _a[SemanticConventions.OPENINFERENCE_SPAN_KIND] = OpenInferenceSpanKind.LLM, _a[SemanticConventions.LLM_MODEL_NAME] = body.model, _a[SemanticConventions.INPUT_VALUE] = JSON.stringify(body), _a[SemanticConventions.INPUT_MIME_TYPE] = MimeType.JSON, _a[SemanticConventions.LLM_INVOCATION_PARAMETERS] = JSON.stringify(invocationParameters), _a[SemanticConventions.LLM_SYSTEM] = LLMSystem.OPENAI, _a[SemanticConventions.LLM_PROVIDER] = LLMProvider.OPENAI, _a), getLLMInputMessagesAttributes(body)), getLLMToolsJSONSchema(body)),
+                    attributes: {
+                        [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.LLM,
+                        [SemanticConventions.LLM_MODEL_NAME]: body.model,
+                        [SemanticConventions.INPUT_VALUE]: JSON.stringify(body),
+                        [SemanticConventions.INPUT_MIME_TYPE]: MimeType.JSON,
+                        [SemanticConventions.LLM_INVOCATION_PARAMETERS]: JSON.stringify(invocationParameters),
+                        [SemanticConventions.LLM_SYSTEM]: LLMSystem.OPENAI,
+                        [SemanticConventions.LLM_PROVIDER]: LLMProvider.OPENAI,
+                        ...getLLMInputMessagesAttributes(body),
+                        ...getLLMToolsJSONSchema(body),
+                    },
                 });
-                var execContext = getExecContext(span);
-                var execPromise = safeExecuteInTheMiddle(function () {
-                    return context.with(trace.setSpan(execContext, span), function () {
-                        return original.apply(_this, args);
+                const execContext = getExecContext(span);
+                const execPromise = safeExecuteInTheMiddle(() => {
+                    return context.with(trace.setSpan(execContext, span), () => {
+                        return original.apply(this, args);
                     });
-                }, function (error) {
+                }, (error) => {
                     // Push the error to the span
                     if (error) {
                         span.recordException(error);
@@ -209,11 +103,17 @@ var OpenAIInstrumentation = /** @class */ (function (_super) {
                         span.end();
                     }
                 });
-                var wrappedPromise = execPromise.then(function (result) {
-                    var _a;
+                const wrappedPromise = execPromise.then((result) => {
                     if (isChatCompletionResponse(result)) {
                         // Record the results
-                        span.setAttributes(__assign(__assign((_a = {}, _a[SemanticConventions.OUTPUT_VALUE] = JSON.stringify(result), _a[SemanticConventions.OUTPUT_MIME_TYPE] = MimeType.JSON, _a[SemanticConventions.LLM_MODEL_NAME] = result.model, _a), getChatCompletionLLMOutputMessagesAttributes(result)), getUsageAttributes(result)));
+                        span.setAttributes({
+                            [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(result),
+                            [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
+                            // Override the model from the value sent by the server
+                            [SemanticConventions.LLM_MODEL_NAME]: result.model,
+                            ...getChatCompletionLLMOutputMessagesAttributes(result),
+                            ...getUsageAttributes(result),
+                        });
                         span.setStatus({ code: SpanStatusCode.OK });
                         span.end();
                     }
@@ -221,7 +121,7 @@ var OpenAIInstrumentation = /** @class */ (function (_super) {
                         // This is a streaming response
                         // handle the chunks and add them to the span
                         // First split the stream via tee
-                        var _b = __read(result.tee(), 2), leftStream = _b[0], rightStream = _b[1];
+                        const [leftStream, rightStream] = result.tee();
                         consumeChatCompletionStreamChunks(rightStream, span);
                         result = leftStream;
                     }
@@ -232,26 +132,27 @@ var OpenAIInstrumentation = /** @class */ (function (_super) {
         });
         this._wrap(module.OpenAI.Completions.prototype, "create", 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        function (original) {
-            return function patchedCreate() {
-                var _a;
-                var _this = this;
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var body = args[0];
-                var _prompt = body.prompt, invocationParameters = __rest(body, ["prompt"]);
-                var span = instrumentation.oiTracer.startSpan("OpenAI Completions", {
+        (original) => {
+            return function patchedCreate(...args) {
+                const body = args[0];
+                const { prompt: _prompt, ...invocationParameters } = body;
+                const span = instrumentation.oiTracer.startSpan(`OpenAI Completions`, {
                     kind: SpanKind.INTERNAL,
-                    attributes: __assign((_a = {}, _a[SemanticConventions.OPENINFERENCE_SPAN_KIND] = OpenInferenceSpanKind.LLM, _a[SemanticConventions.LLM_MODEL_NAME] = body.model, _a[SemanticConventions.LLM_INVOCATION_PARAMETERS] = JSON.stringify(invocationParameters), _a[SemanticConventions.LLM_SYSTEM] = LLMSystem.OPENAI, _a[SemanticConventions.LLM_PROVIDER] = LLMProvider.OPENAI, _a), getCompletionInputValueAndMimeType(body)),
+                    attributes: {
+                        [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.LLM,
+                        [SemanticConventions.LLM_MODEL_NAME]: body.model,
+                        [SemanticConventions.LLM_INVOCATION_PARAMETERS]: JSON.stringify(invocationParameters),
+                        [SemanticConventions.LLM_SYSTEM]: LLMSystem.OPENAI,
+                        [SemanticConventions.LLM_PROVIDER]: LLMProvider.OPENAI,
+                        ...getCompletionInputValueAndMimeType(body),
+                    },
                 });
-                var execContext = getExecContext(span);
-                var execPromise = safeExecuteInTheMiddle(function () {
-                    return context.with(trace.setSpan(execContext, span), function () {
-                        return original.apply(_this, args);
+                const execContext = getExecContext(span);
+                const execPromise = safeExecuteInTheMiddle(() => {
+                    return context.with(trace.setSpan(execContext, span), () => {
+                        return original.apply(this, args);
                     });
-                }, function (error) {
+                }, (error) => {
                     // Push the error to the span
                     if (error) {
                         span.recordException(error);
@@ -262,11 +163,17 @@ var OpenAIInstrumentation = /** @class */ (function (_super) {
                         span.end();
                     }
                 });
-                var wrappedPromise = execPromise.then(function (result) {
-                    var _a;
+                const wrappedPromise = execPromise.then((result) => {
                     if (isCompletionResponse(result)) {
                         // Record the results
-                        span.setAttributes(__assign(__assign((_a = {}, _a[SemanticConventions.OUTPUT_VALUE] = JSON.stringify(result), _a[SemanticConventions.OUTPUT_MIME_TYPE] = MimeType.JSON, _a[SemanticConventions.LLM_MODEL_NAME] = result.model, _a), getCompletionOutputValueAndMimeType(result)), getUsageAttributes(result)));
+                        span.setAttributes({
+                            [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(result),
+                            [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
+                            // Override the model from the value sent by the server
+                            [SemanticConventions.LLM_MODEL_NAME]: result.model,
+                            ...getCompletionOutputValueAndMimeType(result),
+                            ...getUsageAttributes(result),
+                        });
                         span.setStatus({ code: SpanStatusCode.OK });
                         span.end();
                     }
@@ -277,31 +184,31 @@ var OpenAIInstrumentation = /** @class */ (function (_super) {
         });
         this._wrap(module.OpenAI.Embeddings.prototype, "create", 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        function (original) {
-            return function patchedEmbeddingCreate() {
-                var _a;
-                var _this = this;
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var body = args[0];
-                var input = body.input;
-                var isStringInput = typeof input === "string";
-                var span = instrumentation.oiTracer.startSpan("OpenAI Embeddings", {
+        (original) => {
+            return function patchedEmbeddingCreate(...args) {
+                const body = args[0];
+                const { input } = body;
+                const isStringInput = typeof input === "string";
+                const span = instrumentation.oiTracer.startSpan(`OpenAI Embeddings`, {
                     kind: SpanKind.INTERNAL,
-                    attributes: __assign((_a = {}, _a[SemanticConventions.OPENINFERENCE_SPAN_KIND] = OpenInferenceSpanKind.EMBEDDING, _a[SemanticConventions.EMBEDDING_MODEL_NAME] = body.model, _a[SemanticConventions.INPUT_VALUE] = isStringInput
-                        ? input
-                        : JSON.stringify(input), _a[SemanticConventions.INPUT_MIME_TYPE] = isStringInput
-                        ? MimeType.TEXT
-                        : MimeType.JSON, _a), getEmbeddingTextAttributes(body)),
+                    attributes: {
+                        [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.EMBEDDING,
+                        [SemanticConventions.EMBEDDING_MODEL_NAME]: body.model,
+                        [SemanticConventions.INPUT_VALUE]: isStringInput
+                            ? input
+                            : JSON.stringify(input),
+                        [SemanticConventions.INPUT_MIME_TYPE]: isStringInput
+                            ? MimeType.TEXT
+                            : MimeType.JSON,
+                        ...getEmbeddingTextAttributes(body),
+                    },
                 });
-                var execContext = getExecContext(span);
-                var execPromise = safeExecuteInTheMiddle(function () {
-                    return context.with(trace.setSpan(execContext, span), function () {
-                        return original.apply(_this, args);
+                const execContext = getExecContext(span);
+                const execPromise = safeExecuteInTheMiddle(() => {
+                    return context.with(trace.setSpan(execContext, span), () => {
+                        return original.apply(this, args);
                     });
-                }, function (error) {
+                }, (error) => {
                     // Push the error to the span
                     if (error) {
                         span.recordException(error);
@@ -312,10 +219,13 @@ var OpenAIInstrumentation = /** @class */ (function (_super) {
                         span.end();
                     }
                 });
-                var wrappedPromise = execPromise.then(function (result) {
+                const wrappedPromise = execPromise.then((result) => {
                     if (result) {
                         // Record the results
-                        span.setAttributes(__assign({}, getEmbeddingEmbeddingsAttributes(result)));
+                        span.setAttributes({
+                            // Do not record the output data as it can be large
+                            ...getEmbeddingEmbeddingsAttributes(result),
+                        });
                     }
                     span.setStatus({ code: SpanStatusCode.OK });
                     span.end();
@@ -330,15 +240,15 @@ var OpenAIInstrumentation = /** @class */ (function (_super) {
             module.openInferencePatched = true;
         }
         catch (e) {
-            diag.debug("Failed to set ".concat(MODULE_NAME, " patched flag on the module"), e);
+            diag.debug(`Failed to set ${MODULE_NAME} patched flag on the module`, e);
         }
         return module;
-    };
+    }
     /**
      * Un-patches the OpenAI module's chat completions API
      */
-    OpenAIInstrumentation.prototype.unpatch = function (moduleExports, moduleVersion) {
-        diag.debug("Removing patch for ".concat(MODULE_NAME, "@").concat(moduleVersion));
+    unpatch(moduleExports, moduleVersion) {
+        diag.debug(`Removing patch for ${MODULE_NAME}@${moduleVersion}`);
         this._unwrap(moduleExports.OpenAI.Chat.Completions.prototype, "create");
         this._unwrap(moduleExports.OpenAI.Completions.prototype, "create");
         this._unwrap(moduleExports.OpenAI.Embeddings.prototype, "create");
@@ -348,12 +258,10 @@ var OpenAIInstrumentation = /** @class */ (function (_super) {
             moduleExports.openInferencePatched = false;
         }
         catch (e) {
-            diag.warn("Failed to unset ".concat(MODULE_NAME, " patched flag on the module"), e);
+            diag.warn(`Failed to unset ${MODULE_NAME} patched flag on the module`, e);
         }
-    };
-    return OpenAIInstrumentation;
-}(InstrumentationBase));
-export { OpenAIInstrumentation };
+    }
+}
 /**
  * type-guard that checks if the response is a chat completion response
  */
@@ -370,29 +278,18 @@ function isCompletionResponse(response) {
  * type-guard that checks if completion prompt attribute is an array of strings
  */
 function isPromptStringArray(prompt) {
-    return (Array.isArray(prompt) && prompt.every(function (item) { return typeof item === "string"; }));
+    return (Array.isArray(prompt) && prompt.every((item) => typeof item === "string"));
 }
 /**
  * Converts the body of a chat completions request to LLM input messages
  */
 function getLLMInputMessagesAttributes(body) {
-    return body.messages.reduce(function (acc, message, index) {
-        var e_1, _a;
-        var messageAttributes = getChatCompletionInputMessageAttributes(message);
-        var indexPrefix = "".concat(SemanticConventions.LLM_INPUT_MESSAGES, ".").concat(index, ".");
-        try {
-            // Flatten the attributes on the index prefix
-            for (var _b = __values(Object.entries(messageAttributes)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
-                acc["".concat(indexPrefix).concat(key)] = value;
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
+    return body.messages.reduce((acc, message, index) => {
+        const messageAttributes = getChatCompletionInputMessageAttributes(message);
+        const indexPrefix = `${SemanticConventions.LLM_INPUT_MESSAGES}.${index}.`;
+        // Flatten the attributes on the index prefix
+        for (const [key, value] of Object.entries(messageAttributes)) {
+            acc[`${indexPrefix}${key}`] = value;
         }
         return acc;
     }, {});
@@ -405,9 +302,9 @@ function getLLMToolsJSONSchema(body) {
         // If tools is undefined, return an empty object
         return {};
     }
-    return body.tools.reduce(function (acc, tool, index) {
-        var toolJsonSchema = safelyJSONStringify(tool);
-        var key = "".concat(SemanticConventions.LLM_TOOLS, ".").concat(index, ".").concat(SemanticConventions.TOOL_JSON_SCHEMA);
+    return body.tools.reduce((acc, tool, index) => {
+        const toolJsonSchema = safelyJSONStringify(tool);
+        const key = `${SemanticConventions.LLM_TOOLS}.${index}.${SemanticConventions.TOOL_JSON_SCHEMA}`;
         if (toolJsonSchema) {
             acc[key] = toolJsonSchema;
         }
@@ -415,25 +312,24 @@ function getLLMToolsJSONSchema(body) {
     }, {});
 }
 function getChatCompletionInputMessageAttributes(message) {
-    var _a;
-    var role = message.role;
-    var attributes = (_a = {},
-        _a[SemanticConventions.MESSAGE_ROLE] = role,
-        _a);
+    const role = message.role;
+    const attributes = {
+        [SemanticConventions.MESSAGE_ROLE]: role,
+    };
     // Add the content only if it is a string
     if (typeof message.content === "string") {
         attributes[SemanticConventions.MESSAGE_CONTENT] = message.content;
     }
     else if (Array.isArray(message.content)) {
-        message.content.forEach(function (part, index) {
-            var contentsIndexPrefix = "".concat(SemanticConventions.MESSAGE_CONTENTS, ".").concat(index, ".");
+        message.content.forEach((part, index) => {
+            const contentsIndexPrefix = `${SemanticConventions.MESSAGE_CONTENTS}.${index}.`;
             if (part.type === "text") {
-                attributes["".concat(contentsIndexPrefix).concat(SemanticConventions.MESSAGE_CONTENT_TYPE)] = "text";
-                attributes["".concat(contentsIndexPrefix).concat(SemanticConventions.MESSAGE_CONTENT_TEXT)] = part.text;
+                attributes[`${contentsIndexPrefix}${SemanticConventions.MESSAGE_CONTENT_TYPE}`] = "text";
+                attributes[`${contentsIndexPrefix}${SemanticConventions.MESSAGE_CONTENT_TEXT}`] = part.text;
             }
             else if (part.type === "image_url") {
-                attributes["".concat(contentsIndexPrefix).concat(SemanticConventions.MESSAGE_CONTENT_TYPE)] = "image";
-                attributes["".concat(contentsIndexPrefix).concat(SemanticConventions.MESSAGE_CONTENT_IMAGE)] = part.image_url.url;
+                attributes[`${contentsIndexPrefix}${SemanticConventions.MESSAGE_CONTENT_TYPE}`] = "image";
+                attributes[`${contentsIndexPrefix}${SemanticConventions.MESSAGE_CONTENT_IMAGE}`] = part.image_url.url;
             }
         });
     }
@@ -443,16 +339,16 @@ function getChatCompletionInputMessageAttributes(message) {
             break;
         case "assistant":
             if (message.tool_calls) {
-                message.tool_calls.forEach(function (toolCall, index) {
-                    var toolCallIndexPrefix = "".concat(SemanticConventions.MESSAGE_TOOL_CALLS, ".").concat(index, ".");
+                message.tool_calls.forEach((toolCall, index) => {
+                    const toolCallIndexPrefix = `${SemanticConventions.MESSAGE_TOOL_CALLS}.${index}.`;
                     // Add the tool call id if it exists
                     if (toolCall.id) {
-                        attributes["".concat(toolCallIndexPrefix).concat(SemanticConventions.TOOL_CALL_ID)] = toolCall.id;
+                        attributes[`${toolCallIndexPrefix}${SemanticConventions.TOOL_CALL_ID}`] = toolCall.id;
                     }
                     // Make sure the tool call has a function
                     if (toolCall.function) {
-                        attributes["".concat(toolCallIndexPrefix).concat(SemanticConventions.TOOL_CALL_FUNCTION_NAME)] = toolCall.function.name;
-                        attributes["".concat(toolCallIndexPrefix).concat(SemanticConventions.TOOL_CALL_FUNCTION_ARGUMENTS_JSON)] = toolCall.function.arguments;
+                        attributes[`${toolCallIndexPrefix}${SemanticConventions.TOOL_CALL_FUNCTION_NAME}`] = toolCall.function.name;
+                        attributes[`${toolCallIndexPrefix}${SemanticConventions.TOOL_CALL_FUNCTION_ARGUMENTS_JSON}`] = toolCall.function.arguments;
                     }
                 });
             }
@@ -462,7 +358,7 @@ function getChatCompletionInputMessageAttributes(message) {
             break;
         case "tool":
             if (message.tool_call_id) {
-                attributes["".concat(SemanticConventions.MESSAGE_TOOL_CALL_ID)] =
+                attributes[`${SemanticConventions.MESSAGE_TOOL_CALL_ID}`] =
                     message.tool_call_id;
             }
             break;
@@ -479,22 +375,21 @@ function getChatCompletionInputMessageAttributes(message) {
  * Converts the body of a completions request to input attributes
  */
 function getCompletionInputValueAndMimeType(body) {
-    var _a, _b;
     if (typeof body.prompt === "string") {
-        return _a = {},
-            _a[SemanticConventions.INPUT_VALUE] = body.prompt,
-            _a[SemanticConventions.INPUT_MIME_TYPE] = MimeType.TEXT,
-            _a;
+        return {
+            [SemanticConventions.INPUT_VALUE]: body.prompt,
+            [SemanticConventions.INPUT_MIME_TYPE]: MimeType.TEXT,
+        };
     }
     else if (isPromptStringArray(body.prompt)) {
-        var prompt = body.prompt[0]; // Only single prompts are currently supported
+        const prompt = body.prompt[0]; // Only single prompts are currently supported
         if (prompt === undefined) {
             return {};
         }
-        return _b = {},
-            _b[SemanticConventions.INPUT_VALUE] = prompt,
-            _b[SemanticConventions.INPUT_MIME_TYPE] = MimeType.TEXT,
-            _b;
+        return {
+            [SemanticConventions.INPUT_VALUE]: prompt,
+            [SemanticConventions.INPUT_MIME_TYPE]: MimeType.TEXT,
+        };
     }
     // Other cases in which the prompt is a token or array of tokens are currently unsupported
     return {};
@@ -503,13 +398,12 @@ function getCompletionInputValueAndMimeType(body) {
  * Get usage attributes
  */
 function getUsageAttributes(completion) {
-    var _a;
     if (completion.usage) {
-        return _a = {},
-            _a[SemanticConventions.LLM_TOKEN_COUNT_COMPLETION] = completion.usage.completion_tokens,
-            _a[SemanticConventions.LLM_TOKEN_COUNT_PROMPT] = completion.usage.prompt_tokens,
-            _a[SemanticConventions.LLM_TOKEN_COUNT_TOTAL] = completion.usage.total_tokens,
-            _a;
+        return {
+            [SemanticConventions.LLM_TOKEN_COUNT_COMPLETION]: completion.usage.completion_tokens,
+            [SemanticConventions.LLM_TOKEN_COUNT_PROMPT]: completion.usage.prompt_tokens,
+            [SemanticConventions.LLM_TOKEN_COUNT_TOTAL]: completion.usage.total_tokens,
+        };
     }
     return {};
 }
@@ -518,46 +412,34 @@ function getUsageAttributes(completion) {
  */
 function getChatCompletionLLMOutputMessagesAttributes(chatCompletion) {
     // Right now support just the first choice
-    var choice = chatCompletion.choices[0];
+    const choice = chatCompletion.choices[0];
     if (!choice) {
         return {};
     }
-    return [choice.message].reduce(function (acc, message, index) {
-        var e_2, _a;
-        var indexPrefix = "".concat(SemanticConventions.LLM_OUTPUT_MESSAGES, ".").concat(index, ".");
-        var messageAttributes = getChatCompletionOutputMessageAttributes(message);
-        try {
-            // Flatten the attributes on the index prefix
-            for (var _b = __values(Object.entries(messageAttributes)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
-                acc["".concat(indexPrefix).concat(key)] = value;
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
+    return [choice.message].reduce((acc, message, index) => {
+        const indexPrefix = `${SemanticConventions.LLM_OUTPUT_MESSAGES}.${index}.`;
+        const messageAttributes = getChatCompletionOutputMessageAttributes(message);
+        // Flatten the attributes on the index prefix
+        for (const [key, value] of Object.entries(messageAttributes)) {
+            acc[`${indexPrefix}${key}`] = value;
         }
         return acc;
     }, {});
 }
 function getChatCompletionOutputMessageAttributes(message) {
-    var _a;
-    var role = message.role;
-    var attributes = (_a = {},
-        _a[SemanticConventions.MESSAGE_ROLE] = role,
-        _a);
+    const role = message.role;
+    const attributes = {
+        [SemanticConventions.MESSAGE_ROLE]: role,
+    };
     if (message.content) {
         attributes[SemanticConventions.MESSAGE_CONTENT] = message.content;
     }
     if (message.tool_calls) {
-        message.tool_calls.forEach(function (toolCall, index) {
-            var toolCallIndexPrefix = "".concat(SemanticConventions.MESSAGE_TOOL_CALLS, ".").concat(index, ".");
+        message.tool_calls.forEach((toolCall, index) => {
+            const toolCallIndexPrefix = `${SemanticConventions.MESSAGE_TOOL_CALLS}.${index}.`;
             // Add the tool call id if it exists
             if (toolCall.id) {
-                attributes["".concat(toolCallIndexPrefix).concat(SemanticConventions.TOOL_CALL_ID)] = toolCall.id;
+                attributes[`${toolCallIndexPrefix}${SemanticConventions.TOOL_CALL_ID}`] = toolCall.id;
             }
             // Double check that the tool call has a function
             // NB: OpenAI only supports tool calls with functions right now but this may change
@@ -580,33 +462,31 @@ function getChatCompletionOutputMessageAttributes(message) {
  * Converts the completion result to output attributes
  */
 function getCompletionOutputValueAndMimeType(completion) {
-    var _a;
     // Right now support just the first choice
-    var choice = completion.choices[0];
+    const choice = completion.choices[0];
     if (!choice) {
         return {};
     }
-    return _a = {},
-        _a[SemanticConventions.OUTPUT_VALUE] = String(choice.text),
-        _a[SemanticConventions.OUTPUT_MIME_TYPE] = MimeType.TEXT,
-        _a;
+    return {
+        [SemanticConventions.OUTPUT_VALUE]: String(choice.text),
+        [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.TEXT,
+    };
 }
 /**
  * Converts the embedding result payload to embedding attributes
  */
 function getEmbeddingTextAttributes(request) {
-    var _a;
     if (typeof request.input === "string") {
-        return _a = {},
-            _a["".concat(SemanticConventions.EMBEDDING_EMBEDDINGS, ".0.").concat(SemanticConventions.EMBEDDING_TEXT)] = request.input,
-            _a;
+        return {
+            [`${SemanticConventions.EMBEDDING_EMBEDDINGS}.0.${SemanticConventions.EMBEDDING_TEXT}`]: request.input,
+        };
     }
     else if (Array.isArray(request.input) &&
         request.input.length > 0 &&
         typeof request.input[0] === "string") {
-        return request.input.reduce(function (acc, input, index) {
-            var indexPrefix = "".concat(SemanticConventions.EMBEDDING_EMBEDDINGS, ".").concat(index, ".");
-            acc["".concat(indexPrefix).concat(SemanticConventions.EMBEDDING_TEXT)] = input;
+        return request.input.reduce((acc, input, index) => {
+            const indexPrefix = `${SemanticConventions.EMBEDDING_EMBEDDINGS}.${index}.`;
+            acc[`${indexPrefix}${SemanticConventions.EMBEDDING_TEXT}`] = input;
             return acc;
         }, {});
     }
@@ -617,9 +497,9 @@ function getEmbeddingTextAttributes(request) {
  * Converts the embedding result payload to embedding attributes
  */
 function getEmbeddingEmbeddingsAttributes(response) {
-    return response.data.reduce(function (acc, embedding, index) {
-        var indexPrefix = "".concat(SemanticConventions.EMBEDDING_EMBEDDINGS, ".").concat(index, ".");
-        acc["".concat(indexPrefix).concat(SemanticConventions.EMBEDDING_VECTOR)] =
+    return response.data.reduce((acc, embedding, index) => {
+        const indexPrefix = `${SemanticConventions.EMBEDDING_EMBEDDINGS}.${index}.`;
+        acc[`${indexPrefix}${SemanticConventions.EMBEDDING_VECTOR}`] =
             embedding.embedding;
         return acc;
     }, {});
@@ -627,103 +507,47 @@ function getEmbeddingEmbeddingsAttributes(response) {
 /**
  * Consumes the stream chunks and adds them to the span
  */
-function consumeChatCompletionStreamChunks(stream, span) {
-    return __awaiter(this, void 0, void 0, function () {
-        var streamResponse, toolAndFunctionCallAttributes, chunk, choice, toolAndFunctionCallAttributesDiff, _a, _b, _c, key, value, e_3_1, messageIndexPrefix, attributes, _d, _e, _f, key, value;
-        var e_4, _g, _h, e_5, _j;
-        var _k, stream_1, stream_1_1;
-        var _l, e_3, _m, _o;
-        return __generator(this, function (_p) {
-            switch (_p.label) {
-                case 0:
-                    streamResponse = "";
-                    toolAndFunctionCallAttributes = {};
-                    _p.label = 1;
-                case 1:
-                    _p.trys.push([1, 6, 7, 12]);
-                    _k = true, stream_1 = __asyncValues(stream);
-                    _p.label = 2;
-                case 2: return [4 /*yield*/, stream_1.next()];
-                case 3:
-                    if (!(stream_1_1 = _p.sent(), _l = stream_1_1.done, !_l)) return [3 /*break*/, 5];
-                    _o = stream_1_1.value;
-                    _k = false;
-                    chunk = _o;
-                    if (chunk.choices.length <= 0) {
-                        return [3 /*break*/, 4];
-                    }
-                    choice = chunk.choices[0];
-                    if (choice.delta.content) {
-                        streamResponse += choice.delta.content;
-                    }
-                    toolAndFunctionCallAttributesDiff = getToolAndFunctionCallAttributesFromStreamChunk(chunk);
-                    try {
-                        for (_a = (e_4 = void 0, __values(Object.entries(toolAndFunctionCallAttributesDiff))), _b = _a.next(); !_b.done; _b = _a.next()) {
-                            _c = __read(_b.value, 2), key = _c[0], value = _c[1];
-                            if (isString(toolAndFunctionCallAttributes[key]) && isString(value)) {
-                                toolAndFunctionCallAttributes[key] += value;
-                            }
-                            else if (isString(value)) {
-                                toolAndFunctionCallAttributes[key] = value;
-                            }
-                        }
-                    }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                    finally {
-                        try {
-                            if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
-                        }
-                        finally { if (e_4) throw e_4.error; }
-                    }
-                    _p.label = 4;
-                case 4:
-                    _k = true;
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 12];
-                case 6:
-                    e_3_1 = _p.sent();
-                    e_3 = { error: e_3_1 };
-                    return [3 /*break*/, 12];
-                case 7:
-                    _p.trys.push([7, , 10, 11]);
-                    if (!(!_k && !_l && (_m = stream_1.return))) return [3 /*break*/, 9];
-                    return [4 /*yield*/, _m.call(stream_1)];
-                case 8:
-                    _p.sent();
-                    _p.label = 9;
-                case 9: return [3 /*break*/, 11];
-                case 10:
-                    if (e_3) throw e_3.error;
-                    return [7 /*endfinally*/];
-                case 11: return [7 /*endfinally*/];
-                case 12:
-                    messageIndexPrefix = "".concat(SemanticConventions.LLM_OUTPUT_MESSAGES, ".0.");
-                    attributes = (_h = {},
-                        _h[SemanticConventions.OUTPUT_VALUE] = streamResponse,
-                        _h[SemanticConventions.OUTPUT_MIME_TYPE] = MimeType.TEXT,
-                        _h["".concat(messageIndexPrefix).concat(SemanticConventions.MESSAGE_CONTENT)] = streamResponse,
-                        _h["".concat(messageIndexPrefix).concat(SemanticConventions.MESSAGE_ROLE)] = "assistant",
-                        _h);
-                    try {
-                        // Add the tool and function call attributes
-                        for (_d = __values(Object.entries(toolAndFunctionCallAttributes)), _e = _d.next(); !_e.done; _e = _d.next()) {
-                            _f = __read(_e.value, 2), key = _f[0], value = _f[1];
-                            attributes["".concat(messageIndexPrefix).concat(key)] = value;
-                        }
-                    }
-                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                    finally {
-                        try {
-                            if (_e && !_e.done && (_j = _d.return)) _j.call(_d);
-                        }
-                        finally { if (e_5) throw e_5.error; }
-                    }
-                    span.setAttributes(attributes);
-                    span.end();
-                    return [2 /*return*/];
+async function consumeChatCompletionStreamChunks(stream, span) {
+    let streamResponse = "";
+    // Tool and function call attributes can also arrive in the stream
+    // NB: the tools and function calls arrive in partial diffs
+    // So the final tool and function calls need to be aggregated
+    // across chunks
+    const toolAndFunctionCallAttributes = {};
+    // The first message is for the assistant response so we start at 1
+    for await (const chunk of stream) {
+        if (chunk.choices.length <= 0) {
+            continue;
+        }
+        const choice = chunk.choices[0];
+        if (choice.delta.content) {
+            streamResponse += choice.delta.content;
+        }
+        // Accumulate the tool and function call attributes
+        const toolAndFunctionCallAttributesDiff = getToolAndFunctionCallAttributesFromStreamChunk(chunk);
+        for (const [key, value] of Object.entries(toolAndFunctionCallAttributesDiff)) {
+            if (isString(toolAndFunctionCallAttributes[key]) && isString(value)) {
+                toolAndFunctionCallAttributes[key] += value;
             }
-        });
-    });
+            else if (isString(value)) {
+                toolAndFunctionCallAttributes[key] = value;
+            }
+        }
+    }
+    const messageIndexPrefix = `${SemanticConventions.LLM_OUTPUT_MESSAGES}.0.`;
+    // Append the attributes to the span as a message
+    const attributes = {
+        [SemanticConventions.OUTPUT_VALUE]: streamResponse,
+        [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.TEXT,
+        [`${messageIndexPrefix}${SemanticConventions.MESSAGE_CONTENT}`]: streamResponse,
+        [`${messageIndexPrefix}${SemanticConventions.MESSAGE_ROLE}`]: "assistant",
+    };
+    // Add the tool and function call attributes
+    for (const [key, value] of Object.entries(toolAndFunctionCallAttributes)) {
+        attributes[`${messageIndexPrefix}${key}`] = value;
+    }
+    span.setAttributes(attributes);
+    span.end();
 }
 /**
  * Extracts the semantic attributes from the stream chunk for tool_calls and function_calls
@@ -732,14 +556,14 @@ function getToolAndFunctionCallAttributesFromStreamChunk(chunk) {
     if (chunk.choices.length <= 0) {
         return {};
     }
-    var choice = chunk.choices[0];
-    var attributes = {};
+    const choice = chunk.choices[0];
+    const attributes = {};
     if (choice.delta.tool_calls) {
-        choice.delta.tool_calls.forEach(function (toolCall, index) {
-            var toolCallIndexPrefix = "".concat(SemanticConventions.MESSAGE_TOOL_CALLS, ".").concat(index, ".");
+        choice.delta.tool_calls.forEach((toolCall, index) => {
+            const toolCallIndexPrefix = `${SemanticConventions.MESSAGE_TOOL_CALLS}.${index}.`;
             // Add the tool call id if it exists
             if (toolCall.id) {
-                attributes["".concat(toolCallIndexPrefix).concat(SemanticConventions.TOOL_CALL_ID)] = toolCall.id;
+                attributes[`${toolCallIndexPrefix}${SemanticConventions.TOOL_CALL_ID}`] = toolCall.id;
             }
             // Double check that the tool call has a function
             // NB: OpenAI only supports tool calls with functions right now but this may change