weflayr 0.21.0 → 0.22.0

package/index.d.ts

@@ -62,7 +62,7 @@ export const AIProviderName: {
 export type AIProviderName = (typeof AIProviderName)[keyof typeof AIProviderName];
 
 export interface SetupOptions {
-  /** Weflayr API key. The server resolves your client_id from this token. */
+  /** Weflayr API key. The server resolves your project_uuid from this token. */
   apiKey: string;
   /** Override the intake base URL. Defaults to WEFLAYR_BASE_URL or https://api.weflayr.com. */
   baseUrl?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weflayr",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Weflayr Node.js SDK — instrument any LLM client via JS Proxy",
   "main": "src/index.js",
   "types": "index.d.ts",

package/src/instrumentation/anthropic/get_streaming_stop_reason_telemetry.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * Streamed stop-reason enrichment for the Anthropic chat span.
+ *
+ * `@traceloop/instrumentation-anthropic` accumulates a streamed response into a
+ * result object but never reads the `message_delta` chunk's `delta.stop_reason`,
+ * so streamed spans format their output message with an empty `finish_reason`.
+ *
+ * `_streamingWrapPromise(client, moduleExports, { span, type, promise })`
+ * returns `new moduleExports.APIPromise(...)` whose parse step wraps the real
+ * SDK stream with the instrumentor's accumulating iterator. This complement
+ * hands it a patched `moduleExports` whose APIPromise interposes on that parse
+ * step, observing the chunks (outside the accumulating iterator, so every chunk
+ * is seen before the iterator finishes) to capture the stop reason — which is
+ * then injected into the accumulated result just before `_endSpan` formats the
+ * output message.
+ */
+
+class AnthropicStreamingStopReasonInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+    // span -> stop_reason captured from the stream's message_delta chunk.
+    this._stopReasonBySpan = new WeakMap();
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is an empty streamed finish_reason, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+
+    const stopReasonBySpan = this._stopReasonBySpan;
+
+    async function* observeStopReason(stream, span) {
+      for await (const chunk of stream) {
+        try {
+          if (
+            chunk &&
+            chunk.type === 'message_delta' &&
+            chunk.delta &&
+            chunk.delta.stop_reason != null
+          ) {
+            stopReasonBySpan.set(span, chunk.delta.stop_reason);
+          }
+        } catch {
+          // Never break the caller's stream over an enrichment failure.
+        }
+        yield chunk;
+      }
+    }
+
+    const streamOriginal = instrumentation._streamingWrapPromise;
+    if (typeof streamOriginal === 'function') {
+      instrumentation._streamingWrapPromise = function streamWithStopReason(
+        client,
+        moduleExports,
+        opts
+      ) {
+        const span = opts && opts.span;
+        if (!span || !moduleExports || typeof moduleExports.APIPromise !== 'function') {
+          return streamOriginal.call(this, client, moduleExports, opts);
+        }
+        class APIPromiseWithStopReason extends moduleExports.APIPromise {
+          constructor(promiseClient, responsePromise, parseResponse) {
+            super(promiseClient, responsePromise, async (parseClient, props) => {
+              const stream = await parseResponse(parseClient, props);
+              try {
+                if (
+                  stream &&
+                  typeof stream[Symbol.asyncIterator] === 'function' &&
+                  typeof stream.constructor === 'function'
+                ) {
+                  return new stream.constructor(
+                    () => observeStopReason(stream, span),
+                    stream.controller
+                  );
+                }
+              } catch {
+                // Fall through to the unobserved stream.
+              }
+              return stream;
+            });
+          }
+        }
+        // The SDK's module exports are non-writable, so the override is an own
+        // defined property shadowing the inherited one.
+        const patchedModuleExports = Object.create(moduleExports, {
+          APIPromise: { value: APIPromiseWithStopReason, configurable: true },
+        });
+        return streamOriginal.call(this, client, patchedModuleExports, opts);
+      };
+      this._patched.push([instrumentation, '_streamingWrapPromise', streamOriginal]);
+    }
+
+    const endSpanOriginal = instrumentation._endSpan;
+    if (typeof endSpanOriginal === 'function') {
+      instrumentation._endSpan = function endSpanWithStopReason(args) {
+        try {
+          const captured = args && args.span && stopReasonBySpan.get(args.span);
+          if (captured != null && args.result && args.result.stop_reason == null) {
+            args.result.stop_reason = captured;
+          }
+        } catch {
+          // Never break span finalization over an enrichment failure.
+        }
+        return endSpanOriginal.call(this, args);
+      };
+      this._patched.push([instrumentation, '_endSpan', endSpanOriginal]);
+    }
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { AnthropicStreamingStopReasonInstrumentor };

package/src/instrumentation/anthropic/get_tool_definitions_telemetry.js

@@ -0,0 +1,50 @@
+'use strict';
+
+/**
+ * Tool-definitions enrichment for the Anthropic chat span.
+ *
+ * `@traceloop/instrumentation-anthropic` records the request model/temperature
+ * attributes in `startSpan({ type, params })` but never the request's `tools`,
+ * so tool-using calls carry no `gen_ai.tool.definitions`. Wrap `startSpan` to
+ * stamp them in the same `{name, description, input_schema}` shape the request
+ * uses. The span processor strips the attribute when message-content capture is
+ * disabled.
+ */
+
+class AnthropicToolDefinitionsInstrumentor {
+  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 missing tool definitions, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+    const startSpanOriginal = instrumentation.startSpan;
+    if (typeof startSpanOriginal !== 'function') return;
+
+    instrumentation.startSpan = function startSpanWithToolDefinitions(request) {
+      const span = startSpanOriginal.call(this, request);
+      try {
+        const tools = request && request.params && request.params.tools;
+        if (Array.isArray(tools) && tools.length) {
+          span.setAttribute('gen_ai.tool.definitions', JSON.stringify(tools));
+        }
+      } catch {
+        // Never break span creation over an enrichment failure.
+      }
+      return span;
+    };
+    this._patched.push([instrumentation, 'startSpan', startSpanOriginal]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { AnthropicToolDefinitionsInstrumentor };

package/src/instrumentation/anthropic/set_telemetry_attributes.js

@@ -3,16 +3,26 @@
 /**
  * Anthropic telemetry complement — the registered orchestrator.
  *
- * Wires the one weflayr-supplied patch the traceloop Anthropic instrumentor
+ * Wires the weflayr-supplied patches the traceloop Anthropic instrumentor
  * misses: cached-prompt token counts on the chat span (it reads them off the
- * response but writes no `gen_ai.usage.cache_*` attribute).
+ * response but writes no `gen_ai.usage.cache_*` attribute), the request's tool
+ * definitions, and the streamed stop reason (its stream accumulator drops it,
+ * leaving an empty finish_reason on the output message).
  */
 
 const { AnthropicPromptCachingInstrumentor } = require('./get_cache_and_reasoning_telemetry');
+const {
+  AnthropicStreamingStopReasonInstrumentor,
+} = require('./get_streaming_stop_reason_telemetry');
+const { AnthropicToolDefinitionsInstrumentor } = require('./get_tool_definitions_telemetry');
 
 class AnthropicTelemetryInstrumentor {
   constructor() {
-    this._subInstrumentors = [new AnthropicPromptCachingInstrumentor()];
+    this._subInstrumentors = [
+      new AnthropicPromptCachingInstrumentor(),
+      new AnthropicStreamingStopReasonInstrumentor(),
+      new AnthropicToolDefinitionsInstrumentor(),
+    ];
   }
 
   instrument(instrumentation) {

package/src/instrumentation/bedrock/get_input_message_content_telemetry.js

@@ -0,0 +1,94 @@
+'use strict';
+
+/**
+ * Input message content for Bedrock invoke_model spans the instrumentor misses.
+ *
+ * `@traceloop/instrumentation-bedrock` parses the request body per model vendor,
+ * so a call whose model id has no recognizable vendor (e.g. an invalid model —
+ * exactly the error spans) gets no `gen_ai.input.messages`. Wrap the
+ * instrumentor's `_startSpan({ params })` to stamp the input messages from the
+ * request body whenever the instrumentor did not. The span processor strips the
+ * attribute when message-content capture is disabled.
+ */
+
+function _contentToParts(content) {
+  if (typeof content === 'string') {
+    return [{ type: 'text', content }];
+  }
+  if (Array.isArray(content)) {
+    return content
+      .filter((block) => block && typeof block.text === 'string')
+      .map((block) => ({ type: 'text', content: block.text }));
+  }
+  return [];
+}
+
+// Messages in the role+parts shape from an InvokeModel JSON body — the
+// `messages` schema (Nova, Anthropic-on-Bedrock) or the flat `inputText` /
+// `prompt` schemas (Titan, legacy).
+function _inputMessagesFromRequestBody(rawBody) {
+  if (typeof rawBody !== 'string') return [];
+  let body;
+  try {
+    body = JSON.parse(rawBody);
+  } catch {
+    return [];
+  }
+  if (!body || typeof body !== 'object') return [];
+  if (Array.isArray(body.messages)) {
+    return body.messages
+      .filter((message) => message && typeof message === 'object')
+      .map((message) => ({
+        role: String(message.role || ''),
+        parts: _contentToParts(message.content),
+      }));
+  }
+  const prompt = body.inputText || body.prompt;
+  if (typeof prompt === 'string') {
+    return [{ role: 'user', parts: [{ type: 'text', content: prompt }] }];
+  }
+  return [];
+}
+
+class BedrockInputMessageContentInstrumentor {
+  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 missing input messages, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+    const original = instrumentation._startSpan;
+    if (typeof original !== 'function') return;
+
+    instrumentation._startSpan = function startSpanWithInputMessages(request) {
+      const span = original.call(this, request);
+      try {
+        const attributes = span && span.attributes;
+        if (attributes && attributes['gen_ai.input.messages'] == null) {
+          const body =
+            request && request.params && request.params.input && request.params.input.body;
+          const messages = _inputMessagesFromRequestBody(body);
+          if (messages.length) {
+            span.setAttribute('gen_ai.input.messages', JSON.stringify(messages));
+          }
+        }
+      } catch {
+        // Never break span creation over an enrichment failure.
+      }
+      return span;
+    };
+    this._patched.push([instrumentation, '_startSpan', original]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { BedrockInputMessageContentInstrumentor };

package/src/instrumentation/bedrock/get_streaming_output_message_telemetry.js

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * Streamed-output message content for the Bedrock invoke_model stream span.
+ *
+ * `@traceloop/instrumentation-bedrock` accumulates the streamed text but formats
+ * the final `gen_ai.output.messages` by passing that string through its chat
+ * block mapper, which only accepts block arrays — so streamed Nova spans end up
+ * with an assistant message whose `parts` is empty. This complement wraps the
+ * instrumentor's per-chunk `_handleNovaStreamingMetadata(span, parsedResponse)`
+ * hook: it accumulates the `contentBlockDelta` text and the `messageStop` stop
+ * reason itself, and re-stamps a correct output message when the trailing
+ * `metadata` chunk (always last in a Nova stream) arrives — after the
+ * instrumentor has written its empty-parts message. The span processor strips
+ * the attribute when message-content capture is disabled.
+ */
+
+// Nova stop reasons mapped to the OTel finish_reason values the instrumentor
+// uses on non-streamed spans, so streamed and non-streamed rows normalize alike.
+const FINISH_REASON_BY_STOP_REASON = {
+  end_turn: 'stop',
+  stop_sequence: 'stop',
+  max_tokens: 'length',
+  tool_use: 'tool_call',
+};
+
+class BedrockStreamingOutputMessageInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+    // span -> {text, stopReason} accumulated across the stream's chunks.
+    this._streamStateBySpan = new WeakMap();
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is an empty streamed output message, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+    const original = instrumentation._handleNovaStreamingMetadata;
+    if (typeof original !== 'function') return;
+
+    const streamStateBySpan = this._streamStateBySpan;
+    instrumentation._handleNovaStreamingMetadata = function handleWithOutputMessage(
+      span,
+      parsedResponse
+    ) {
+      try {
+        const state = streamStateBySpan.get(span) || { text: '', stopReason: null };
+        const delta =
+          parsedResponse &&
+          parsedResponse.contentBlockDelta &&
+          parsedResponse.contentBlockDelta.delta &&
+          parsedResponse.contentBlockDelta.delta.text;
+        if (typeof delta === 'string') state.text += delta;
+        const stopReason =
+          parsedResponse && parsedResponse.messageStop && parsedResponse.messageStop.stopReason;
+        if (stopReason != null) state.stopReason = stopReason;
+        streamStateBySpan.set(span, state);
+
+        if (parsedResponse && parsedResponse.metadata && state.text) {
+          const message = {
+            role: 'assistant',
+            parts: [{ type: 'text', content: state.text }],
+          };
+          if (state.stopReason != null) {
+            message.finish_reason =
+              FINISH_REASON_BY_STOP_REASON[state.stopReason] || state.stopReason;
+          }
+          span.setAttribute('gen_ai.output.messages', JSON.stringify([message]));
+        }
+      } catch {
+        // Never break the caller's stream over an enrichment failure.
+      }
+      return original.call(this, span, parsedResponse);
+    };
+    this._patched.push([instrumentation, '_handleNovaStreamingMetadata', original]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { BedrockStreamingOutputMessageInstrumentor };

package/src/instrumentation/bedrock/set_telemetry_attributes.js

@@ -3,16 +3,25 @@
 /**
  * Bedrock telemetry complement — the registered orchestrator.
  *
- * Wires the one weflayr-supplied patch the traceloop Bedrock instrumentor misses:
+ * Wires the weflayr-supplied patches the traceloop Bedrock instrumentor misses:
  * cached-prompt token counts on the invoke_model span (Nova returns them in the
- * response body but traceloop never reads them).
+ * response body but traceloop never reads them) and the streamed output message
+ * content (its stream path formats an empty-parts message).
  */
 
 const { BedrockPromptCachingInstrumentor } = require('./get_cache_telemetry');
+const { BedrockInputMessageContentInstrumentor } = require('./get_input_message_content_telemetry');
+const {
+  BedrockStreamingOutputMessageInstrumentor,
+} = require('./get_streaming_output_message_telemetry');
 
 class BedrockTelemetryInstrumentor {
   constructor() {
-    this._subInstrumentors = [new BedrockPromptCachingInstrumentor()];
+    this._subInstrumentors = [
+      new BedrockPromptCachingInstrumentor(),
+      new BedrockInputMessageContentInstrumentor(),
+      new BedrockStreamingOutputMessageInstrumentor(),
+    ];
   }
 
   instrument(instrumentation) {

package/src/instrumentation/cohere/get_embeddings_telemetry.js

@@ -36,6 +36,16 @@ function _wrapEmbed(owner, patched) {
     if (request && request.model) {
       span.setAttribute('gen_ai.request.model', request.model);
     }
+    // The embedded texts are the prompt; stamp one user message per text, like
+    // the chat path. The span processor strips it when content capture is off.
+    if (request && Array.isArray(request.texts) && request.texts.length) {
+      span.setAttribute(
+        'gen_ai.input.messages',
+        JSON.stringify(
+          request.texts.map((text) => ({ role: 'user', parts: [{ type: 'text', content: text }] }))
+        )
+      );
+    }
     return Promise.resolve(original.call(this, request, ...rest)).then(
       (response) => {
         // Node SDK reports the billed input tokens under camelCase keys.

package/src/instrumentation/google/get_audio_telemetry.js

@@ -5,8 +5,7 @@
  *
  * 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).
+ * `gen_ai.usage.{input,output}_tokens_details.audio_tokens`.
  */
 
 // Sum the token counts whose modality is AUDIO across a *TokensDetails array.

package/src/instrumentation/google/get_cache_telemetry.js

@@ -6,9 +6,7 @@
  * 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).
+ * `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');

package/src/instrumentation/google/get_embeddings_telemetry.js

@@ -9,7 +9,7 @@
  * 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).
+ * num_input_chars).
  */
 
 const { trace, SpanStatusCode } = require('@opentelemetry/api');
@@ -34,6 +34,18 @@ function _contentCharacters(contents) {
   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);
@@ -58,6 +70,15 @@ function instrumentEmbeddings(Models, patched) {
       '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();

package/src/instrumentation/openai/get_embeddings_telemetry.js

@@ -60,6 +60,18 @@ class OpenAIEmbeddingsInstrumentor {
       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) {

package/src/otel/exporter.js

@@ -77,7 +77,6 @@ function buildExporter({
   });
   const originalExport = exporter.export.bind(exporter);
   const wrappedExport = _exportWithRetry(originalExport, { maxRetries, maxRetryMs });
-  let warned = false;
   exporter.export = (spans, resultCallback) => {
     const start = Date.now();
     debug('exporter.export: posting count=%d', spans.length);
@@ -93,11 +92,7 @@ function buildExporter({
           result?.code,
           result?.error?.message || result?.error || '(none)'
         );
-        // Surface the first failure on stderr so users notice broken setups
-        // even without NODE_DEBUG=weflayr. Stay quiet after — repeated warns
-        // on a misconfigured key would just spam.
-        if (warnOnExportError && !warned) {
-          warned = true;
+        if (warnOnExportError) {
           // console.warn writes to stderr synchronously. process.emitWarning
           // is queued for the next tick, so a caller doing process.exit() from
           // their error handler races past it and the warning is lost.

package/src/otel/span-processor.js

@@ -22,6 +22,29 @@ const { EXTRA_TAG_PREFIX, getMergedMetadataFromContext } = require('./propagatio
 const { isDefaultExportSpan, isKnownLLMInstrumentor } = require('./span-filter');
 const { debug } = require('../logger');
 
+// setup({captureMessageContent: ...}) records the choice in this env var (the
+// official OTel GenAI one). Instrumentors gate content on their own knobs
+// (openllmetry reads its own config and captures by default), so the processor
+// enforces the flag itself: when the env var is "false", message content is
+// stripped from every span before export.
+const CONTENT_CAPTURE_ENV = 'OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT';
+
+// The new-semconv JSON message attributes and the legacy indexed
+// `gen_ai.prompt.{i}.*` / `gen_ai.completion.{i}.*` attributes.
+const CONTENT_ATTRIBUTES = [
+  'gen_ai.input.messages',
+  'gen_ai.output.messages',
+  'gen_ai.system_instructions',
+];
+const CONTENT_ATTRIBUTE_PREFIXES = ['gen_ai.prompt.', 'gen_ai.completion.'];
+
+function _isContentAttribute(key) {
+  return (
+    CONTENT_ATTRIBUTES.includes(key) ||
+    CONTENT_ATTRIBUTE_PREFIXES.some((prefix) => key.startsWith(prefix))
+  );
+}
+
 class WeflayrSpanProcessor {
   constructor({ exporter, exportMode = 'batch', defaultTags = {}, mask, shouldExportSpan } = {}) {
     if (!exporter) {
@@ -77,6 +100,12 @@ class WeflayrSpanProcessor {
     }
     debug('span end: exporting name=%s scope=%s', span.name, span.instrumentationScope?.name);
 
+    if ((process.env[CONTENT_CAPTURE_ENV] || '').toLowerCase() === 'false') {
+      for (const key of Object.keys(span.attributes)) {
+        if (_isContentAttribute(key)) delete span.attributes[key];
+      }
+    }
+
     if (this._mask) {
       try {
         const masked = this._mask(span.attributes);
@@ -120,4 +149,4 @@ class WeflayrSpanProcessor {
   }
 }
 
-module.exports = { WeflayrSpanProcessor };
+module.exports = { CONTENT_CAPTURE_ENV, WeflayrSpanProcessor };

package/src/setup.js

@@ -5,13 +5,12 @@ const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
 const { resourceFromAttributes } = require('@opentelemetry/resources');
 
 const { buildExporter } = require('./otel/exporter');
-const { WeflayrSpanProcessor } = require('./otel/span-processor');
+const { CONTENT_CAPTURE_ENV, WeflayrSpanProcessor } = require('./otel/span-processor');
 const { debug } = require('./logger');
 const { version: SDK_VERSION } = require('../package.json');
 
 const SDK_LANGUAGE = 'javascript';
 const DEFAULT_BASE_URL = 'https://api.weflayr.com';
-const CONTENT_CAPTURE_ENV = 'OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT';
 
 const _state = {
   tracerProvider: null,