weflayr 0.20.5 → 0.21.0

package/src/instrumentation/elevenlabs/full_instrumentation.js

@@ -0,0 +1,236 @@
+'use strict';
+
+/**
+ * Hand-written OTel instrumentor for the ElevenLabs audio clients.
+ *
+ * No official OpenTelemetry instrumentor exists for the ElevenLabs SDK (it's
+ * audio, not an LLM), so this ships inside weflayr. It wraps the Text-to-Speech
+ * and Speech-to-Text entrypoints to emit one `gen_ai.*` span per call, which
+ * flows through the standard span processor -> exporter with no new transport code.
+ *
+ * The billable unit differs by API, so each span records the one ElevenLabs bills:
+ *   - Text-to-Speech is billed per input character -> `gen_ai.usage.input_characters`.
+ *   - Speech-to-Text is billed per second of audio  -> `gen_ai.usage.input_seconds`.
+ *
+ * Entrypoints come in three result shapes, independent of which API they belong to:
+ *   - *byte stream* methods resolve to a `ReadableStream` of audio chunks;
+ *   - *object stream* methods resolve to an async-iterable of chunk objects;
+ *   - *unary* methods resolve to the full response.
+ * The HTTP request -- plus any error -- only happens while a stream is awaited
+ * and consumed, so the span is started eagerly (to capture the
+ * `propagateMetadata` context active at the call site) and ended once the result
+ * is exhausted (streams) or returned (unary), giving an `elapsed_ms` that covers
+ * the whole call. The per-second billable unit is read off the STT response.
+ */
+
+const { trace, SpanStatusCode } = require('@opentelemetry/api');
+
+const TRACER_NAME = 'weflayr.instrumentation.elevenlabs';
+const SYSTEM = 'elevenlabs';
+const TTS_OPERATION = 'text_to_speech';
+const STT_OPERATION = 'speech_to_text';
+
+function _startSpan(operation, request) {
+  const span = trace.getTracer(TRACER_NAME).startSpan(operation);
+  span.setAttribute('gen_ai.system', SYSTEM);
+  span.setAttribute('gen_ai.operation.name', operation);
+  // `modelId` lives on the request body passed to every audio entrypoint.
+  const modelId = request && request.modelId;
+  if (modelId) {
+    span.setAttribute('gen_ai.request.model', modelId);
+  }
+  return span;
+}
+
+function _setInputCharacters(span, request) {
+  // `text` lives on the request body of every TTS entrypoint; the billable unit
+  // is its length.
+  span.setAttribute('gen_ai.usage.input_characters', ((request && request.text) || '').length);
+}
+
+function _setAudioDuration(span, response) {
+  // The transcription response exposes the transcribed audio length in seconds.
+  const durationSecs = response && response.audioDurationSecs;
+  if (durationSecs != null) {
+    span.setAttribute('gen_ai.usage.input_seconds', durationSecs);
+  }
+}
+
+function _recordError(span, error) {
+  span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message ?? String(error) });
+  span.recordException(error);
+}
+
+// Proxy a `ReadableStream` of audio bytes so the span ends -- and any error is
+// recorded -- once the whole stream has been consumed (or the consumer cancels).
+// The span ends exactly once across every exit path.
+function _consumeByteStream(span, responsePromise) {
+  let ended = false;
+  const end = () => {
+    if (ended) return;
+    ended = true;
+    span.end();
+  };
+
+  return responsePromise.then(
+    (audioStream) => {
+      const reader = audioStream.getReader();
+      return new ReadableStream({
+        async pull(controller) {
+          try {
+            const { done, value } = await reader.read();
+            if (done) {
+              end();
+              controller.close();
+              return;
+            }
+            controller.enqueue(value);
+          } catch (error) {
+            _recordError(span, error);
+            end();
+            controller.error(error);
+          }
+        },
+        cancel(reason) {
+          end();
+          return reader.cancel(reason);
+        },
+      });
+    },
+    (error) => {
+      _recordError(span, error);
+      end();
+      throw error;
+    }
+  );
+}
+
+// Proxy an async-iterable of chunk objects (the streaming "with timestamps"
+// variant) so the span ends once iteration completes.
+function _consumeObjectStream(span, responsePromise) {
+  async function* iterate(stream) {
+    try {
+      for await (const chunk of stream) {
+        yield chunk;
+      }
+    } catch (error) {
+      _recordError(span, error);
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+
+  return responsePromise.then(
+    (stream) => iterate(stream),
+    (error) => {
+      _recordError(span, error);
+      span.end();
+      throw error;
+    }
+  );
+}
+
+// Wrap a request/response entrypoint: the span spans the single call, and any
+// response-derived billable unit is read off the result.
+function _consumeUnary(span, responsePromise, setResponseAttributes) {
+  return responsePromise.then(
+    (response) => {
+      if (setResponseAttributes) {
+        setResponseAttributes(span, response);
+      }
+      span.end();
+      return response;
+    },
+    (error) => {
+      _recordError(span, error);
+      span.end();
+      throw error;
+    }
+  );
+}
+
+class ElevenLabsInstrumentor {
+  constructor() {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  instrument() {
+    let TextToSpeechClient;
+    let SpeechToTextClient;
+    try {
+      ({
+        TextToSpeechClient,
+      } = require('@elevenlabs/elevenlabs-js/api/resources/textToSpeech/client/Client'));
+      ({
+        SpeechToTextClient,
+      } = require('@elevenlabs/elevenlabs-js/api/resources/speechToText/client/Client'));
+    } catch (err) {
+      throw new Error(
+        'weflayr.autoInstrument(ELEVENLABS): the @elevenlabs/elevenlabs-js client is not ' +
+          'installed. Install it with: npm install @elevenlabs/elevenlabs-js\n' +
+          `Underlying error: ${err.message}`
+      );
+    }
+
+    // TTS — request body is the 2nd arg (after voice_id); billed per character.
+    this._wrap(TextToSpeechClient.prototype, 'convert', {
+      operation: TTS_OPERATION,
+      requestArgIndex: 1,
+      setRequestAttributes: _setInputCharacters,
+      consume: _consumeByteStream,
+    });
+    this._wrap(TextToSpeechClient.prototype, 'stream', {
+      operation: TTS_OPERATION,
+      requestArgIndex: 1,
+      setRequestAttributes: _setInputCharacters,
+      consume: _consumeByteStream,
+    });
+    this._wrap(TextToSpeechClient.prototype, 'streamWithTimestamps', {
+      operation: TTS_OPERATION,
+      requestArgIndex: 1,
+      setRequestAttributes: _setInputCharacters,
+      consume: _consumeObjectStream,
+    });
+    this._wrap(TextToSpeechClient.prototype, 'convertWithTimestamps', {
+      operation: TTS_OPERATION,
+      requestArgIndex: 1,
+      setRequestAttributes: _setInputCharacters,
+      consume: (span, responsePromise) => _consumeUnary(span, responsePromise, null),
+    });
+
+    // STT — request body is the 1st arg; billed per second of audio.
+    this._wrap(SpeechToTextClient.prototype, 'convert', {
+      operation: STT_OPERATION,
+      requestArgIndex: 0,
+      setRequestAttributes: null,
+      consume: (span, responsePromise) => _consumeUnary(span, responsePromise, _setAudioDuration),
+    });
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+
+  _wrap(owner, methodName, { operation, requestArgIndex, setRequestAttributes, consume }) {
+    const original = owner[methodName];
+
+    function wrapper(...args) {
+      const request = args[requestArgIndex];
+      const span = _startSpan(operation, request);
+      if (setRequestAttributes) {
+        setRequestAttributes(span, request);
+      }
+      return consume(span, original.apply(this, args));
+    }
+
+    owner[methodName] = wrapper;
+    this._patched.push([owner, methodName, original]);
+  }
+}
+
+module.exports = { ElevenLabsInstrumentor };

package/src/instrumentation/google/get_audio_telemetry.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * Per-modality audio token enrichment for the Google GenAI (Gemini) chat span.
+ *
+ * Neither instrumentor breaks usage down by modality, so for audio in/out (e.g.
+ * Gemini TTS) we read the response's per-modality token details and set
+ * `gen_ai.usage.{input,output}_tokens_details.audio_tokens` (normalized to
+ * token_audio_input / token_audio_output).
+ */
+
+// Sum the token counts whose modality is AUDIO across a *TokensDetails array.
+function _audioTokens(details) {
+  if (!Array.isArray(details)) return 0;
+  return details.reduce(
+    (total, detail) => total + (detail && detail.modality === 'AUDIO' ? detail.tokenCount || 0 : 0),
+    0
+  );
+}
+
+function setAudioTelemetry(span, response) {
+  const usage = response && response.usageMetadata;
+  if (!usage) return;
+  const inputAudio = _audioTokens(usage.promptTokensDetails);
+  const outputAudio = _audioTokens(usage.candidatesTokensDetails);
+  if (inputAudio) span.setAttribute('gen_ai.usage.input_tokens_details.audio_tokens', inputAudio);
+  if (outputAudio)
+    span.setAttribute('gen_ai.usage.output_tokens_details.audio_tokens', outputAudio);
+}
+
+module.exports = { setAudioTelemetry, _audioTokens };

package/src/instrumentation/google/get_cache_telemetry.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * Context-caching token enrichment for the Google GenAI (Gemini) chat span.
+ *
+ * Neither instrumentor records cached-content tokens, so we read
+ * `usageMetadata.cachedContentTokenCount` (explicit or implicit caching) and
+ * split it by modality: audio cached tokens go to
+ * `gen_ai.usage.input_tokens_details.cached_audio_tokens` (normalized to
+ * token_audio_cached) and the remainder to `gen_ai.usage.cache_read_input_tokens`
+ * (normalized to token_text_cached).
+ */
+
+const { _audioTokens } = require('./get_audio_telemetry');
+
+function setCacheTelemetry(span, response) {
+  const usage = response && response.usageMetadata;
+  const cachedTokens = (usage && usage.cachedContentTokenCount) || 0;
+  if (!cachedTokens) return;
+  const cachedAudio = _audioTokens(usage.cacheTokensDetails);
+  if (cachedAudio)
+    span.setAttribute('gen_ai.usage.input_tokens_details.cached_audio_tokens', cachedAudio);
+  const cacheRead = Math.max(0, cachedTokens - cachedAudio);
+  if (cacheRead) span.setAttribute('gen_ai.usage.cache_read_input_tokens', cacheRead);
+}
+
+module.exports = { setCacheTelemetry };

package/src/instrumentation/google/get_embeddings_telemetry.js

@@ -0,0 +1,78 @@
+'use strict';
+
+/**
+ * Embeddings-endpoint telemetry for Google GenAI (Gemini).
+ *
+ * `@traceloop/instrumentation-google-generativeai` wraps generate_content but not
+ * embeddings, so this covers it by starting its own span on the private
+ * `Models.prototype.embedContentInternal` (which the public `embedContent`
+ * delegates to). The Gemini Developer API returns NO token usage on embedContent
+ * (only Vertex does), so the span records the billable unit weflayr can price:
+ * the input character count under `gen_ai.usage.input_characters` (normalized to
+ * count_char).
+ */
+
+const { trace, SpanStatusCode } = require('@opentelemetry/api');
+
+const { getProviderName } = require('./get_provider_name');
+
+const TRACER_NAME = 'weflayr.instrumentation.google.embeddings';
+const EMBEDDINGS_OPERATION = 'embeddings';
+
+// `contents` is a string, a Content/Part object, or an array of those; the
+// billable unit is the total number of characters of text across them.
+function _contentCharacters(contents) {
+  if (contents == null) return 0;
+  if (typeof contents === 'string') return contents.length;
+  if (Array.isArray(contents)) {
+    return contents.reduce((total, item) => total + _contentCharacters(item), 0);
+  }
+  if (typeof contents === 'object') {
+    if (typeof contents.text === 'string') return contents.text.length;
+    if (Array.isArray(contents.parts)) return _contentCharacters(contents.parts);
+  }
+  return 0;
+}
+
+function _recordError(span, error) {
+  span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message ?? String(error) });
+  span.recordException(error);
+}
+
+// Wrap `Models.prototype.embedContentInternal`, pushing the restore tuple onto
+// the shared `patched` array the orchestrator owns for uninstrument().
+function instrumentEmbeddings(Models, patched) {
+  const owner = Models.prototype;
+  const original = owner.embedContentInternal;
+  if (typeof original !== 'function') return;
+
+  function wrapper(params, ...rest) {
+    const span = trace.getTracer(TRACER_NAME).startSpan(EMBEDDINGS_OPERATION);
+    span.setAttribute('gen_ai.system', getProviderName(this));
+    span.setAttribute('gen_ai.operation.name', EMBEDDINGS_OPERATION);
+    if (params && params.model) {
+      // The chat path strips the leading "models/" prefix; mirror it.
+      span.setAttribute('gen_ai.request.model', params.model.replace(/^models\//, ''));
+    }
+    span.setAttribute(
+      'gen_ai.usage.input_characters',
+      _contentCharacters(params && params.contents)
+    );
+    return Promise.resolve(original.call(this, params, ...rest)).then(
+      (response) => {
+        span.end();
+        return response;
+      },
+      (error) => {
+        _recordError(span, error);
+        span.end();
+        throw error;
+      }
+    );
+  }
+
+  owner.embedContentInternal = wrapper;
+  patched.push([owner, 'embedContentInternal', original]);
+}
+
+module.exports = { instrumentEmbeddings };

package/src/instrumentation/google/get_provider_name.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/**
+ * Provider-name enrichment for the Google GenAI (Gemini) chat span.
+ *
+ * `@traceloop/instrumentation-google-generativeai` hardcodes
+ * `gen_ai.provider.name = "gcp.gen_ai"` and can't tell Vertex from the Gemini
+ * Developer API. We read the client's Vertex flag and return the value to set as
+ * `gen_ai.system` (which the normalizer prefers): `vertex_ai` / `gemini`,
+ * matching what the Python google-genai instrumentor reports natively. Node-only.
+ */
+
+// Read the Vertex-vs-Dev backend off the Models instance's api client.
+function getProviderName(instance) {
+  try {
+    if (instance && instance.apiClient && typeof instance.apiClient.isVertexAI === 'function') {
+      return instance.apiClient.isVertexAI() ? 'vertex_ai' : 'gemini';
+    }
+  } catch {
+    // fall through to default
+  }
+  return 'gemini';
+}
+
+module.exports = { getProviderName };

package/src/instrumentation/google/get_reasoning_telemetry.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * Reasoning (thinking) token enrichment for the Google GenAI (Gemini) chat span.
+ *
+ * Neither instrumentor surfaces the thinking budget. Gemini reports thinking
+ * under `usageMetadata.thoughtsTokenCount`, which is SEPARATE from
+ * `candidatesTokenCount` (the visible output) and excluded from the totals, so
+ * without this the thinking tokens are lost. Stamp them as
+ * `gen_ai.usage.thoughts_token_count` so the normalizer can fold them into the
+ * completion count.
+ */
+
+function setReasoningTelemetry(span, response) {
+  const usage = response && response.usageMetadata;
+  if (!usage) return;
+  const thoughts = usage.thoughtsTokenCount || 0;
+  if (thoughts) span.setAttribute('gen_ai.usage.thoughts_token_count', thoughts);
+}
+
+module.exports = { setReasoningTelemetry };

package/src/instrumentation/google/set_telemetry_attributes.js

@@ -0,0 +1,98 @@
+'use strict';
+
+/**
+ * Google GenAI (Gemini) telemetry complement — the registered orchestrator.
+ *
+ * Wires every weflayr-supplied patch the traceloop Google instrumentor misses:
+ *   - chat span enrichment (one wrap of generateContent{,Stream}Internal that
+ *     stamps provider name + audio tokens + cache tokens — see the get_*_telemetry
+ *     files), and
+ *   - the embeddings endpoint it doesn't cover at all.
+ *
+ * The public arrows delegate to these private prototype methods while the
+ * traceloop span is the active span, so enrichment lands on that span.
+ */
+
+const { trace } = require('@opentelemetry/api');
+
+const { getProviderName } = require('./get_provider_name');
+const { setAudioTelemetry } = require('./get_audio_telemetry');
+const { setCacheTelemetry } = require('./get_cache_telemetry');
+const { setReasoningTelemetry } = require('./get_reasoning_telemetry');
+const { instrumentEmbeddings } = require('./get_embeddings_telemetry');
+
+class GoogleTelemetryInstrumentor {
+  constructor() {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  instrument() {
+    let Models;
+    try {
+      ({ Models } = require('@google/genai'));
+    } catch (err) {
+      throw new Error(
+        'weflayr.autoInstrument(GOOGLE_GENAI): the @google/genai client is not installed. ' +
+          'Install it with: npm install @google/genai\n' +
+          `Underlying error: ${err.message}`
+      );
+    }
+
+    // Non-streaming: stamp provider up front, audio + cache tokens off the response.
+    this._wrapChat(Models.prototype, 'generateContentInternal', { stream: false });
+    // Streaming: stamp provider, then cache tokens off the final chunk's usageMetadata.
+    this._wrapChat(Models.prototype, 'generateContentStreamInternal', { stream: true });
+    // Embeddings: an endpoint the traceloop instrumentor doesn't cover at all.
+    instrumentEmbeddings(Models, this._patched);
+  }
+
+  _wrapChat(owner, methodName, { stream }) {
+    const original = owner[methodName];
+
+    function wrapper(...args) {
+      const span = trace.getActiveSpan();
+      if (!span || !span.isRecording || !span.isRecording()) {
+        return original.apply(this, args);
+      }
+      span.setAttribute('gen_ai.system', getProviderName(this));
+      if (!stream) {
+        return Promise.resolve(original.apply(this, args)).then((response) => {
+          setAudioTelemetry(span, response);
+          setCacheTelemetry(span, response);
+          setReasoningTelemetry(span, response);
+          return response;
+        });
+      }
+      // Streamed: usage (incl. cachedContentTokenCount) lands on the final chunk;
+      // observe the chunks as they pass through. The instrumentor keeps the span
+      // open until the stream is exhausted.
+      return Promise.resolve(original.apply(this, args)).then((stream_) => {
+        if (!stream_ || typeof stream_[Symbol.asyncIterator] !== 'function') return stream_;
+        return (async function* observeCache() {
+          for await (const chunk of stream_) {
+            try {
+              setCacheTelemetry(span, chunk);
+              setReasoningTelemetry(span, chunk);
+            } catch {
+              // Never break the caller's stream over an enrichment failure.
+            }
+            yield chunk;
+          }
+        })();
+      });
+    }
+
+    owner[methodName] = wrapper;
+    this._patched.push([owner, methodName, original]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { GoogleTelemetryInstrumentor };

package/src/instrumentation/openai/get_audio_telemetry.js

@@ -0,0 +1,149 @@
+'use strict';
+
+/**
+ * Hand-written OTel instrumentor for the OpenAI audio endpoints.
+ *
+ * The `@traceloop/instrumentation-openai` package wraps OpenAI's chat,
+ * completions, responses and image endpoints, but not the audio ones, so this
+ * ships inside weflayr to cover them. It wraps the Text-to-Speech and
+ * Speech-to-Text entrypoints to emit one `gen_ai.*` span per call, which flows
+ * through the standard span processor -> exporter with no new transport code. It
+ * is registered alongside the traceloop instrumentor whenever
+ * `autoInstrument({ aiSdks: 'openai' })` runs.
+ *
+ * The billable unit differs by API, so each span records the one OpenAI bills:
+ *   - Text-to-Speech is billed per input character -> `gen_ai.usage.input_characters`.
+ *   - Speech-to-Text is billed per second of audio  -> `gen_ai.usage.input_seconds`.
+ *
+ * Both endpoints are request/response (unary): `audio.speech.create` resolves to
+ * the full audio and `audio.transcriptions.create` to the transcription. The STT
+ * audio length is only present when the call requests `response_format: 'verbose_json'`.
+ */
+
+const { trace, SpanStatusCode } = require('@opentelemetry/api');
+
+const TRACER_NAME = 'weflayr.instrumentation.openai_audio';
+const TTS_OPERATION = 'text_to_speech';
+const STT_OPERATION = 'speech_to_text';
+
+// Return the gen_ai.system for this call, matching how the OpenAI chat
+// instrumentor attributes the vendor: Azure clients (reached via the same openai
+// SDK) report `azure.ai.openai`, everything else `openai`.
+function _detectSystem(instance) {
+  const baseURL = (instance && instance._client && instance._client.baseURL) || '';
+  return baseURL.toLowerCase().includes('openai.azure.com') ? 'azure.ai.openai' : 'openai';
+}
+
+function _startSpan(operation, body, system) {
+  const span = trace.getTracer(TRACER_NAME).startSpan(operation);
+  span.setAttribute('gen_ai.system', system);
+  span.setAttribute('gen_ai.operation.name', operation);
+  // `model` lives on the request body passed to both audio entrypoints.
+  const model = body && body.model;
+  if (model) {
+    span.setAttribute('gen_ai.request.model', model);
+  }
+  return span;
+}
+
+function _setInputCharacters(span, body) {
+  // `input` is the text passed to text_to_speech; the billable unit is its length.
+  span.setAttribute('gen_ai.usage.input_characters', ((body && body.input) || '').length);
+}
+
+function _setAudioDuration(span, response) {
+  // `duration` (seconds) is only present on a verbose transcription response;
+  // it is the billable unit for speech-to-text.
+  const durationSecs = response && response.duration;
+  if (durationSecs != null) {
+    span.setAttribute('gen_ai.usage.input_seconds', durationSecs);
+  }
+}
+
+function _recordError(span, error) {
+  span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message ?? String(error) });
+  span.recordException(error);
+}
+
+// Wrap a request/response entrypoint: the span spans the single call, and any
+// response-derived billable unit is read off the result.
+function _consumeUnary(span, responsePromise, setResponseAttributes) {
+  return responsePromise.then(
+    (response) => {
+      if (setResponseAttributes) {
+        setResponseAttributes(span, response);
+      }
+      span.end();
+      return response;
+    },
+    (error) => {
+      _recordError(span, error);
+      span.end();
+      throw error;
+    }
+  );
+}
+
+class OpenAIAudioInstrumentor {
+  constructor() {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  instrument() {
+    let Speech;
+    let Transcriptions;
+    try {
+      ({ Speech } = require('openai/resources/audio/speech'));
+      ({ Transcriptions } = require('openai/resources/audio/transcriptions'));
+    } catch (err) {
+      throw new Error(
+        'weflayr.autoInstrument(OPENAI): the openai client is not installed. ' +
+          'Install it with: npm install openai\n' +
+          `Underlying error: ${err.message}`
+      );
+    }
+
+    // TTS — request body is the 1st arg; billed per character.
+    this._wrap(Speech.prototype, {
+      operation: TTS_OPERATION,
+      setRequestAttributes: _setInputCharacters,
+      setResponseAttributes: null,
+    });
+
+    // STT — request body is the 1st arg; billed per second of audio.
+    this._wrap(Transcriptions.prototype, {
+      operation: STT_OPERATION,
+      setRequestAttributes: null,
+      setResponseAttributes: _setAudioDuration,
+    });
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+
+  _wrap(owner, { operation, setRequestAttributes, setResponseAttributes }) {
+    const original = owner.create;
+
+    function wrapper(body, ...rest) {
+      const span = _startSpan(operation, body, _detectSystem(this));
+      if (setRequestAttributes) {
+        setRequestAttributes(span, body);
+      }
+      return _consumeUnary(
+        span,
+        Promise.resolve(original.call(this, body, ...rest)),
+        setResponseAttributes
+      );
+    }
+
+    owner.create = wrapper;
+    this._patched.push([owner, 'create', original]);
+  }
+}
+
+module.exports = { OpenAIAudioInstrumentor };