weflayr 0.23.0 → 0.26.0

package/src/instrumentation/google/get_audio_telemetry.js

@@ -1,30 +0,0 @@
-'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`.
- */
-
-// 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

@@ -1,25 +0,0 @@
-'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`and the remainder to `gen_ai.usage.cache_read_input_tokens`
- */
-
-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

@@ -1,99 +0,0 @@
-'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
- * num_input_chars).
- */
-
-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;
-}
-
-// The embedded text mapped to the role+parts message shape the chat path uses:
-// a string (or {text} / {parts} object) becomes one user message per content.
-function _contentToMessage(content) {
-  if (typeof content === 'string') {
-    return { role: 'user', parts: [{ type: 'text', content }] };
-  }
-  if (content && typeof content.text === 'string') {
-    return { role: 'user', parts: [{ type: 'text', content: content.text }] };
-  }
-  return { role: 'user', parts: [] };
-}
-
-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)
-    );
-    // The embedded text is the prompt; stamp it like the chat path does. The
-    // span processor strips it when message-content capture is disabled.
-    if (params && params.contents != null) {
-      const contentsList = Array.isArray(params.contents) ? params.contents : [params.contents];
-      span.setAttribute(
-        'gen_ai.input.messages',
-        JSON.stringify(contentsList.map(_contentToMessage))
-      );
-    }
-    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/set_telemetry_attributes.js

@@ -1,98 +0,0 @@
-'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

@@ -1,149 +0,0 @@
-'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 };

package/src/instrumentation/openai/get_cache_and_reasoning_telemetry.js

@@ -1,71 +0,0 @@
-'use strict';
-
-/**
- * Cached-prompt token enrichment complement for the non-streamed OpenAI chat path.
- *
- * `@traceloop/instrumentation-openai` records `gen_ai.usage.{input,output}_tokens`
- * for non-streamed calls but never reads `usage.prompt_tokens_details.cached_tokens`,
- * so spans for prompt-cache hits carry no cached-token count. The Python
- * OpenLLMetry instrumentor sets `gen_ai.usage.cache_read_input_tokens` from that
- * field, so this brings the Node SDK to parity.
- *
- * It wraps the instrumentor instance's `_endSpan({ span, type, result })`, which
- * finalizes the span after the response resolves, letting us stamp the
- * cached-token count off `result.usage` while the span is still open. OpenAI has
- * no separate cache-write count, so only `cache_read_input_tokens` is set.
- *
- * The same hook surfaces the reasoning-token count: reasoning models report it as
- * `usage.completion_tokens_details.reasoning_tokens` (a subset of output_tokens)
- * which the Node instrumentor drops, so this stamps the flat `reasoning_tokens`
- * attribute (the form the Python instrumentor emits and the normalizer reads).
- */
-
-const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
-const REASONING_TOKENS_ATTR = 'gen_ai.usage.reasoning_tokens';
-
-class OpenAIPromptCachingInstrumentor {
-  constructor() {
-    // [instrumentation, methodName, originalFunction] for uninstrument().
-    this._patched = [];
-  }
-
-  // No-op (and never throws) if the instrumentor's internals have changed shape —
-  // the worst case is a missing cached-token count, never a crash.
-  instrument(instrumentation) {
-    const original = instrumentation && instrumentation._endSpan;
-    if (typeof original !== 'function') return;
-
-    instrumentation._endSpan = function endSpanWithCache(args) {
-      try {
-        const span = args && args.span;
-        const usage = args && args.result && args.result.usage;
-        const recording = span && span.isRecording && span.isRecording();
-        const cachedTokens =
-          usage && usage.prompt_tokens_details && usage.prompt_tokens_details.cached_tokens;
-        if (cachedTokens && recording) {
-          span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, cachedTokens);
-        }
-        const reasoningTokens =
-          usage &&
-          usage.completion_tokens_details &&
-          usage.completion_tokens_details.reasoning_tokens;
-        if (reasoningTokens && recording) {
-          span.setAttribute(REASONING_TOKENS_ATTR, reasoningTokens);
-        }
-      } catch {
-        // Never break span finalization over an enrichment failure.
-      }
-      return original.call(this, args);
-    };
-    this._patched.push([instrumentation, '_endSpan', original]);
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-}
-
-module.exports = { OpenAIPromptCachingInstrumentor };

package/src/instrumentation/openai/get_embeddings_telemetry.js

@@ -1,107 +0,0 @@
-'use strict';
-
-/**
- * Hand-written OTel instrumentor for the OpenAI embeddings endpoint.
- *
- * `@traceloop/instrumentation-openai` (the package weflayr uses for OpenAI on
- * Node) does not wrap the embeddings endpoint, so this ships inside weflayr to
- * cover it. The Python SDK gets embeddings for free from OpenLLMetry's
- * instrumentor, so there is no Python counterpart to this file — but the span it
- * emits is shaped to normalize identically. It is registered alongside the
- * traceloop instrumentor whenever `autoInstrument({ aiSdks: 'openai' })` runs.
- *
- * Embeddings are billed per input token, so the span records the prompt tokens
- * read off the response under `gen_ai.usage.input_tokens`; there is no completion.
- */
-
-const { trace, SpanStatusCode } = require('@opentelemetry/api');
-
-const TRACER_NAME = 'weflayr.instrumentation.openai_embeddings';
-const EMBEDDINGS_OPERATION = 'embeddings';
-
-// 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 _recordError(span, error) {
-  span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message ?? String(error) });
-  span.recordException(error);
-}
-
-class OpenAIEmbeddingsInstrumentor {
-  constructor() {
-    // [ownerPrototype, methodName, originalFunction] for uninstrument().
-    this._patched = [];
-  }
-
-  instrument() {
-    let Embeddings;
-    try {
-      ({ Embeddings } = require('openai/resources/embeddings'));
-    } 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}`
-      );
-    }
-
-    const owner = Embeddings.prototype;
-    const original = owner.create;
-
-    function wrapper(body, ...rest) {
-      const span = trace.getTracer(TRACER_NAME).startSpan(EMBEDDINGS_OPERATION);
-      span.setAttribute('gen_ai.system', _detectSystem(this));
-      span.setAttribute('gen_ai.operation.name', EMBEDDINGS_OPERATION);
-      if (body && body.model) {
-        span.setAttribute('gen_ai.request.model', body.model);
-      }
-      // One user message per input element, matching the shape the chat
-      // instrumentors emit. The span processor strips it when message-content
-      // capture is disabled.
-      if (body && body.input != null) {
-        const inputs = Array.isArray(body.input) ? body.input : [body.input];
-        span.setAttribute(
-          'gen_ai.input.messages',
-          JSON.stringify(
-            inputs.map((content) => ({ role: 'user', parts: [{ type: 'text', content }] }))
-          )
-        );
-      }
-      return Promise.resolve(original.call(this, body, ...rest)).then(
-        (response) => {
-          if (response && response.model) {
-            span.setAttribute('gen_ai.response.model', response.model);
-          }
-          const promptTokens = response && response.usage && response.usage.prompt_tokens;
-          if (promptTokens != null) {
-            span.setAttribute('gen_ai.usage.input_tokens', promptTokens);
-          }
-          span.end();
-          return response;
-        },
-        (error) => {
-          _recordError(span, error);
-          span.end();
-          throw error;
-        }
-      );
-    }
-
-    owner.create = wrapper;
-    this._patched.push([owner, 'create', original]);
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-}
-
-module.exports = { OpenAIEmbeddingsInstrumentor };

package/src/instrumentation/openai/get_streaming_usage.js

@@ -1,81 +0,0 @@
-'use strict';
-
-/**
- * Streamed token-usage enrichment complement for the OpenAI chat path.
- *
- * `@traceloop/instrumentation-openai` does not record token usage for streamed
- * calls: its stream handler accumulates `choices[].delta` but never reads the
- * final usage chunk OpenAI sends when the request sets
- * `stream_options: { include_usage: true }`. Non-streaming calls work because
- * OpenAI returns `usage` in the response body, which the instrumentor reads
- * directly. The Python OpenLLMetry instrumentor reads the streamed usage, so
- * this gap is Node-only.
- *
- * It wraps the instrumentor instance's `_streamingWrapPromise`: that handler
- * hands us the span and ends it only after its chunk loop, so when the usage
- * chunk arrives the span is still open and we set the same `gen_ai.usage.*`
- * attributes the instrumentor sets for non-streaming calls.
- */
-
-const USAGE_INPUT_TOKENS_ATTR = 'gen_ai.usage.input_tokens';
-const USAGE_OUTPUT_TOKENS_ATTR = 'gen_ai.usage.output_tokens';
-const USAGE_TOTAL_TOKENS_ATTR = 'gen_ai.usage.total_tokens';
-const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
-
-function _setUsageAttributes(span, usage) {
-  if (typeof usage.prompt_tokens === 'number') {
-    span.setAttribute(USAGE_INPUT_TOKENS_ATTR, usage.prompt_tokens);
-  }
-  if (typeof usage.completion_tokens === 'number') {
-    span.setAttribute(USAGE_OUTPUT_TOKENS_ATTR, usage.completion_tokens);
-  }
-  if (typeof usage.total_tokens === 'number') {
-    span.setAttribute(USAGE_TOTAL_TOKENS_ATTR, usage.total_tokens);
-  }
-  // Cached-prompt tokens ride in the same streamed usage chunk; mirror the
-  // non-streamed cache backfill in get_cache_and_reasoning_telemetry.js.
-  const cachedTokens = usage.prompt_tokens_details && usage.prompt_tokens_details.cached_tokens;
-  if (cachedTokens) {
-    span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, cachedTokens);
-  }
-}
-
-class OpenAIStreamingUsageInstrumentor {
-  constructor() {
-    // [instrumentation, methodName, originalFunction] for uninstrument().
-    this._patched = [];
-  }
-
-  // No-op if the instrumentor's internals have changed shape — the worst case is
-  // streamed spans without token counts, never a crash.
-  instrument(instrumentation) {
-    const original = instrumentation && instrumentation._streamingWrapPromise;
-    if (typeof original !== 'function') return;
-
-    instrumentation._streamingWrapPromise = function streamingWrapWithUsage(streamArgs) {
-      const span = streamArgs && streamArgs.span;
-      const wrappedStream = original.call(this, streamArgs);
-      if (!span) return wrappedStream;
-
-      return (async function* backfillUsage() {
-        for await (const chunk of wrappedStream) {
-          const usage = chunk && chunk.usage;
-          if (usage && span.isRecording()) {
-            _setUsageAttributes(span, usage);
-          }
-          yield chunk;
-        }
-      })();
-    };
-    this._patched.push([instrumentation, '_streamingWrapPromise', original]);
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-}
-
-module.exports = { OpenAIStreamingUsageInstrumentor };