weflayr 0.23.0 → 0.26.0

package/src/instrumentation/openai/set_telemetry_attributes.js

@@ -1,39 +0,0 @@
-'use strict';
-
-/**
- * OpenAI telemetry complement — the registered orchestrator.
- *
- * Wires every weflayr-supplied patch the traceloop OpenAI instrumentor misses:
- *   - the audio (TTS/STT) and embeddings endpoints it doesn't cover, and
- *   - usage it drops on the chat endpoint it does cover: streamed token usage and
- *     non-streamed cached-prompt tokens (these enrich the traceloop instrumentor
- *     instance, hence the `instrumentation` argument).
- */
-
-const { OpenAIAudioInstrumentor } = require('./get_audio_telemetry');
-const { OpenAIEmbeddingsInstrumentor } = require('./get_embeddings_telemetry');
-const { OpenAIStreamingUsageInstrumentor } = require('./get_streaming_usage');
-const { OpenAIPromptCachingInstrumentor } = require('./get_cache_and_reasoning_telemetry');
-
-class OpenAITelemetryInstrumentor {
-  constructor() {
-    this._subInstrumentors = [
-      new OpenAIAudioInstrumentor(),
-      new OpenAIEmbeddingsInstrumentor(),
-      new OpenAIStreamingUsageInstrumentor(),
-      new OpenAIPromptCachingInstrumentor(),
-    ];
-  }
-
-  // The endpoint complements ignore `instrumentation`; the streaming/cache ones
-  // patch its internal handlers.
-  instrument(instrumentation) {
-    for (const sub of this._subInstrumentors) sub.instrument(instrumentation);
-  }
-
-  uninstrument() {
-    for (const sub of this._subInstrumentors) sub.uninstrument();
-  }
-}
-
-module.exports = { OpenAITelemetryInstrumentor };

package/src/instrumentation/vercel/full_instrumentation.js

@@ -1,44 +0,0 @@
-'use strict';
-
-/**
- * Instrumentor for the Vercel AI SDK (`ai` package, v7+).
- *
- * The AI SDK ships its own OTel integration in `@ai-sdk/otel`; instrumenting
- * is registering it globally so every generateText/streamText/embed call emits
- * GenAI semconv spans through the tracer provider weflayr's setup() installed.
- * `usage: true` adds the `ai.usage.*` token details (reasoning tokens, uncached
- * input) that the semconv attributes do not carry.
- *
- * The aggregate spans the integration emits around each model call
- * (invoke_agent, agent_step, duplicated embeddings spans) are filtered out
- * before export by otel/vercel-ai-sdk-span-filter.js.
- */
-class VercelAiSdkInstrumentor {
-  instrument() {
-    let registerTelemetry;
-    let OpenTelemetry;
-    try {
-      ({ registerTelemetry } = require('ai'));
-      ({ OpenTelemetry } = require('@ai-sdk/otel'));
-    } catch (err) {
-      throw new Error(
-        'weflayr.autoInstrument("vercel_ai_gateway"): failed to load "ai" / "@ai-sdk/otel". ' +
-          `Install them with: npm install ai @ai-sdk/otel\nUnderlying error: ${err.message}`
-      );
-    }
-    // registerTelemetry only exists since v7.
-    if (typeof registerTelemetry !== 'function') {
-      throw new Error(
-        'weflayr.autoInstrument("vercel_ai_gateway") requires version 7+ of the Vercel AI SDK ' +
-          '(the "ai" package), which added global telemetry registration. ' +
-          'Upgrade with: npm install ai@latest @ai-sdk/otel.\n' +
-          'On ai <= 6 telemetry can only be enabled per call: remove "vercel_ai_gateway" from ' +
-          'aiSdks (pass an empty list if no other sdks need to be instrumented). Instead, make sure ' +
-          'experimental_telemetry: { isEnabled: true } is passed on each generateText/streamText call.'
-      );
-    }
-    registerTelemetry(new OpenTelemetry({ usage: true }));
-  }
-}
-
-module.exports = { VercelAiSdkInstrumentor };

package/src/logger.js

@@ -1,8 +0,0 @@
-'use strict';
-
-const { debuglog } = require('node:util');
-
-// Enable with NODE_DEBUG=weflayr
-const debug = debuglog('weflayr');
-
-module.exports = { debug };

package/src/otel/exporter.js

@@ -1,108 +0,0 @@
-'use strict';
-
-const retry = require('async-retry');
-const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
-
-const { debug } = require('../logger');
-
-// OTLP-spec retryable statuses: rate-limit + transient server errors.
-const _RETRYABLE_STATUS = new Set([429, 502, 503, 504]);
-
-function _isNonRetryable(err) {
-  // Tells async-retry's `bail` whether to give up: bail on 4xx (other than
-  // 429); retry on retryable statuses and on transport errors (no status).
-  const status = err?.exportResult?.error?.code;
-  return status !== undefined && !_RETRYABLE_STATUS.has(status);
-}
-
-function _formatFailure(result, url) {
-  const err = result?.error;
-  const status = err?.code;
-  const body = typeof err?.data === 'string' ? err.data.slice(0, 200) : undefined;
-  const message = err?.message || String(err) || 'unknown error';
-  let hint = '';
-  if (status === 401 || status === 403) {
-    hint = ' Check your apiKey / WEFLAYR_API_KEY.';
-  } else if (status === 404) {
-    hint = ' Check the baseUrl is correct.';
-  } else if (!status && /ECONN|ENOTFOUND|timeout/i.test(message)) {
-    hint = ' The endpoint is unreachable — check baseUrl and network.';
-  }
-  return (
-    `Weflayr: failed to export telemetry to ${url}` +
-    (status ? ` (HTTP ${status})` : '') +
-    `: ${message}.${hint}` +
-    (body ? ` Response: ${body}` : '')
-  );
-}
-
-// Wrap a callback-style OTel exporter `export(spans, cb)` with retry. Retries
-// transport errors + retryable HTTP statuses; bails on other 4xx.
-function _exportWithRetry(originalExport, { maxRetries, maxRetryMs }) {
-  return (spans, resultCallback) => {
-    retry(
-      async (bail) => {
-        const result = await new Promise((resolve) => originalExport(spans, resolve));
-        if (result?.code === 0) return result;
-        const err = new Error(result?.error?.message || 'export failed');
-        err.exportResult = result;
-        if (_isNonRetryable(err)) {
-          bail(err);
-          return;
-        }
-        throw err;
-      },
-      { retries: maxRetries - 1, minTimeout: 50, maxRetryTime: maxRetryMs, factor: 2 }
-    )
-      .then((result) => resultCallback(result))
-      .catch((err) => resultCallback(err.exportResult || { code: 1, error: err }));
-  };
-}
-
-function buildExporter({
-  baseUrl,
-  apiKey,
-  timeoutMs = 5000,
-  warnOnExportError = true,
-  maxRetries = 2,
-  maxRetryMs = 1000,
-}) {
-  const url = `${baseUrl.replace(/\/$/, '')}/`;
-  const exporter = new OTLPTraceExporter({
-    url,
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-    },
-    timeoutMillis: timeoutMs,
-  });
-  const originalExport = exporter.export.bind(exporter);
-  const wrappedExport = _exportWithRetry(originalExport, { maxRetries, maxRetryMs });
-  exporter.export = (spans, resultCallback) => {
-    const start = Date.now();
-    debug('exporter.export: posting count=%d', spans.length);
-    wrappedExport(spans, (result) => {
-      const ms = Date.now() - start;
-      if (result && result.code === 0) {
-        debug('exporter.export: ok count=%d elapsed_ms=%d', spans.length, ms);
-      } else {
-        debug(
-          'exporter.export: FAIL count=%d elapsed_ms=%d code=%s error=%s',
-          spans.length,
-          ms,
-          result?.code,
-          result?.error?.message || result?.error || '(none)'
-        );
-        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.
-          console.warn(`[weflayr] ${_formatFailure(result, url)}`);
-        }
-      }
-      resultCallback(result);
-    });
-  };
-  return exporter;
-}
-
-module.exports = { buildExporter, _exportWithRetry, _RETRYABLE_STATUS };

package/src/otel/propagation.js

@@ -1,133 +0,0 @@
-// Copyright 2024 Langfuse GmbH
-// Licensed under the MIT License.
-// Original source: https://github.com/langfuse/langfuse-js/blob/main/packages/core/src/propagation.ts
-//
-// Modifications copyright 2026 Weflayr
-// This file has been modified from its original form:
-//   - Translated from TypeScript to JavaScript
-//   - Replaced Langfuse's fixed schema with Weflayr's structured metadata
-//     (featureName, customerName, providerName, extraTags) plus an
-//     auto-generated per-call uuid
-//   - Removed asBaggage cross-process propagation (not needed yet)
-//   - Removed experiment framework keys
-//   - Structured fields are written under stable `weflayr.*` span attribute
-//     keys; extraTags entries are written verbatim
-//
-// See LICENSE-MIT in the package root for the full license text.
-
-'use strict';
-
-const { randomUUID } = require('node:crypto');
-const { context: otelContext, trace, createContextKey } = require('@opentelemetry/api');
-
-const WEFLAYR_METADATA_CONTEXT_KEY = createContextKey('weflayr_metadata');
-
-const FEATURE_NAME_ATTR = 'weflayr.feature_name';
-const CUSTOMER_NAME_ATTR = 'weflayr.customer_name';
-const PROVIDER_NAME_ATTR = 'weflayr.provider_name';
-const UUID_ATTR = 'weflayr.uuid';
-// Prefix for user-supplied `extraTags` so downstream normalizers can pick
-// them out without colliding with instrumentor-set `gen_ai.*` attributes.
-const EXTRA_TAG_PREFIX = 'weflayr.tag.';
-
-function getMergedMetadataFromContext(parentContext) {
-  const ctx = parentContext ?? otelContext.active();
-  const existing = ctx.getValue(WEFLAYR_METADATA_CONTEXT_KEY);
-  return existing && typeof existing === 'object' ? { ...existing } : {};
-}
-
-function _buildAttributes({ featureName, customerName, providerName, extraTags, spanUuid }) {
-  const attributes = {
-    [FEATURE_NAME_ATTR]: featureName,
-    [CUSTOMER_NAME_ATTR]: customerName,
-    [UUID_ATTR]: spanUuid,
-  };
-  for (const [key, value] of Object.entries(extraTags)) {
-    attributes[`${EXTRA_TAG_PREFIX}${key}`] = value;
-  }
-  if (providerName !== undefined && providerName !== null) {
-    attributes[PROVIDER_NAME_ATTR] = providerName;
-  }
-  return attributes;
-}
-
-/**
- * Attach Weflayr metadata to every LLM span created inside this scope.
- *
- * Callable form: `propagateMetadata(options, fn)` runs `fn` immediately.
- * Decorator form: `propagateMetadata(options)` returns a wrapper usable as a
- * function-decorator (`@propagateMetadata(...)` on class methods) or as a
- * plain `wrap(fn)` -> wrappedFn helper. Each invocation of the wrapped
- * function mints a fresh `uuid`, matching the callable form's "one uuid per
- * propagateMetadata call" contract.
- */
-function propagateMetadata(options, fn) {
-  const { featureName, customerId } = options ?? {};
-  let { customerName } = options ?? {};
-  if (customerId != null) {
-    process.emitWarning(
-      'propagateMetadata: `customerId` is deprecated, use `customerName`',
-      'DeprecationWarning'
-    );
-    customerName = customerName ?? customerId;
-  }
-  if (featureName == null || customerName == null) {
-    throw new Error('propagateMetadata: `featureName` and `customerName` are required');
-  }
-  const normalizedOptions = { ...options, customerName };
-
-  if (typeof fn === 'function') {
-    return _runWithMetadata(normalizedOptions, fn);
-  }
-
-  return function decorator(target, key, descriptor) {
-    if (descriptor && typeof descriptor.value === 'function') {
-      const original = descriptor.value;
-      descriptor.value = function wrapped(...args) {
-        return _runWithMetadata(normalizedOptions, () => original.apply(this, args));
-      };
-      return descriptor;
-    }
-    if (typeof target === 'function') {
-      return function wrapped(...args) {
-        return _runWithMetadata(normalizedOptions, () => target.apply(this, args));
-      };
-    }
-    return target;
-  };
-}
-
-function _runWithMetadata(options, fn) {
-  const { featureName, customerName, providerName, extraTags } = options;
-  const attributes = _buildAttributes({
-    featureName,
-    customerName,
-    providerName,
-    extraTags: extraTags ?? {},
-    spanUuid: randomUUID().replace(/-/g, ''),
-  });
-
-  const parent = otelContext.active();
-  const merged = { ...getMergedMetadataFromContext(parent), ...attributes };
-  const newContext = parent.setValue(WEFLAYR_METADATA_CONTEXT_KEY, merged);
-
-  const activeSpan = trace.getActiveSpan();
-  if (activeSpan && activeSpan.isRecording && activeSpan.isRecording()) {
-    for (const [k, v] of Object.entries(attributes)) {
-      activeSpan.setAttribute(k, v);
-    }
-  }
-
-  return otelContext.with(newContext, fn);
-}
-
-module.exports = {
-  propagateMetadata,
-  getMergedMetadataFromContext,
-  WEFLAYR_METADATA_CONTEXT_KEY,
-  FEATURE_NAME_ATTR,
-  CUSTOMER_NAME_ATTR,
-  PROVIDER_NAME_ATTR,
-  UUID_ATTR,
-  EXTRA_TAG_PREFIX,
-};

package/src/otel/span-filter.js

@@ -1,69 +0,0 @@
-// Copyright 2024 Langfuse GmbH
-// Licensed under the MIT License.
-// Original source: https://github.com/langfuse/langfuse-js/blob/main/packages/otel/src/span-filter.ts
-//
-// Modifications copyright 2026 Weflayr
-// This file has been modified from its original form:
-//   - Translated from TypeScript to JavaScript
-//   - Dropped the LANGFUSE_TRACER_NAME special case (we have no SDK-internal tracer)
-//   - Dropped isLangfuseSpan
-//
-// See LICENSE-MIT in the package root for the full license text.
-
-'use strict';
-
-const KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [
-  'agent_framework',
-  'ai',
-  'haystack',
-  'langsmith',
-  'litellm',
-  'openinference',
-  'opentelemetry.instrumentation.anthropic',
-  'opentelemetry.instrumentation.aws_bedrock',
-  'opentelemetry.instrumentation.bedrock',
-  'opentelemetry.instrumentation.gemini',
-  'opentelemetry.instrumentation.google_genai',
-  'opentelemetry.instrumentation.google_generativeai',
-  'opentelemetry.instrumentation.openai',
-  'opentelemetry.instrumentation.openai_v2',
-  'weflayr.instrumentation.elevenlabs',
-  'strands-agents',
-  'vllm',
-  '@traceloop/instrumentation-openai',
-  '@traceloop/instrumentation-anthropic',
-  '@traceloop/instrumentation-bedrock',
-  '@traceloop/instrumentation-cohere',
-  '@traceloop/instrumentation-google-generativeai',
-  '@traceloop/instrumentation-langchain',
-  '@traceloop/instrumentation-llamaindex',
-  '@traceloop/instrumentation-pinecone',
-  '@traceloop/instrumentation-chromadb',
-  '@traceloop/instrumentation-qdrant',
-  '@traceloop/instrumentation-mcp',
-];
-
-const EXACT_LLM_INSTRUMENTATION_SCOPES = new Set(['ai']);
-
-function isGenAISpan(span) {
-  return Object.keys(span.attributes).some((key) => key.startsWith('gen_ai.'));
-}
-
-function isKnownLLMInstrumentor(span) {
-  const scope = span.instrumentationScope.name;
-  return KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES.some(
-    (prefix) =>
-      scope === prefix ||
-      (!EXACT_LLM_INSTRUMENTATION_SCOPES.has(prefix) && scope.startsWith(`${prefix}.`))
-  );
-}
-
-function isDefaultExportSpan(span) {
-  return isGenAISpan(span) || isKnownLLMInstrumentor(span);
-}
-
-module.exports = {
-  isGenAISpan,
-  isKnownLLMInstrumentor,
-  isDefaultExportSpan,
-};

package/src/otel/span-processor.js

@@ -1,162 +0,0 @@
-// Copyright 2024 Langfuse GmbH
-// Licensed under the MIT License.
-// Original source: https://github.com/langfuse/langfuse-js/blob/main/packages/otel/src/span-processor.ts
-//
-// Modifications copyright 2026 Weflayr
-// This file has been modified from its original form:
-//   - Translated from TypeScript to JavaScript
-//   - Removed MediaService integration (no media upload support yet)
-//   - Removed LangfuseAPIClient / app-root marker logic (not used)
-//   - Removed Langfuse-specific span attributes (TRACE_INPUT/OUTPUT/METADATA, IS_APP_ROOT, ENVIRONMENT, RELEASE)
-//   - Mask hook now receives the full flat attribute bag, not a {data} envelope, and runs synchronously
-//   - default_tags are applied as span attributes in onStart
-//   - propagated tags come from Weflayr's tag bag (see propagation.js), not Langfuse's typed schema
-//
-// See LICENSE-MIT in the package root for the full license text.
-
-'use strict';
-
-const { SpanStatusCode } = require('@opentelemetry/api');
-const { BatchSpanProcessor, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base');
-const { EXTRA_TAG_PREFIX, getMergedMetadataFromContext } = require('./propagation');
-const { isDefaultExportSpan, isKnownLLMInstrumentor } = require('./span-filter');
-const {
-  VercelAiSdkSpanFilter,
-  stampVercelGatewayProviderName,
-} = require('./vercel-ai-sdk-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) {
-      throw new Error('WeflayrSpanProcessor: exporter is required');
-    }
-    this._delegate =
-      exportMode === 'immediate'
-        ? new SimpleSpanProcessor(exporter)
-        : new BatchSpanProcessor(exporter);
-    this._defaultTags = defaultTags;
-    this._mask = mask;
-    this._shouldExportSpan = shouldExportSpan ?? isDefaultExportSpan;
-    this._vercelAiSdkSpanFilter = new VercelAiSdkSpanFilter();
-    // LLM spans we've started but not yet seen end. On forceFlush we end any
-    // leftovers with ERROR status — covers cases like openllmetry's anthropic
-    // streaming wrapper, which leaks the span when the underlying call
-    // rejects. Generic across providers; no per-provider patching needed.
-    this._openLlmSpans = new Set();
-  }
-
-  onStart(span, parentContext) {
-    for (const [k, v] of Object.entries(this._defaultTags)) {
-      span.setAttribute(`${EXTRA_TAG_PREFIX}${k}`, v);
-    }
-    const propagated = getMergedMetadataFromContext(parentContext);
-    for (const [k, v] of Object.entries(propagated)) {
-      span.setAttribute(k, v);
-    }
-    if (isKnownLLMInstrumentor(span)) {
-      this._openLlmSpans.add(span);
-    }
-    this._vercelAiSdkSpanFilter.onStart(span);
-    debug(
-      'span start: name=%s defaultTags=%d propagatedMetadata=%d',
-      span.name,
-      Object.keys(this._defaultTags).length,
-      Object.keys(propagated).length
-    );
-    return this._delegate.onStart(span, parentContext);
-  }
-
-  onEnd(span) {
-    this._openLlmSpans.delete(span);
-    try {
-      const vercelVerdict = this._vercelAiSdkSpanFilter.shouldExport(span);
-      if (vercelVerdict === true) {
-        stampVercelGatewayProviderName(span);
-      }
-      if (vercelVerdict === false || (vercelVerdict === null && !this._shouldExportSpan(span))) {
-        debug(
-          'span end: filtered out name=%s scope=%s',
-          span.name,
-          span.instrumentationScope?.name
-        );
-        return;
-      }
-    } catch {
-      return;
-    }
-    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);
-        if (masked && masked !== span.attributes) {
-          for (const k of Object.keys(span.attributes)) delete span.attributes[k];
-          Object.assign(span.attributes, masked);
-        }
-      } catch {
-        for (const k of Object.keys(span.attributes)) delete span.attributes[k];
-      }
-    }
-
-    return this._delegate.onEnd(span);
-  }
-
-  async forceFlush() {
-    this._endOrphanedLlmSpans();
-    return this._delegate.forceFlush();
-  }
-
-  _endOrphanedLlmSpans() {
-    const orphans = [...this._openLlmSpans];
-    this._openLlmSpans.clear();
-    for (const span of orphans) {
-      try {
-        if (typeof span.isRecording === 'function' && !span.isRecording()) continue;
-        span.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: 'weflayr: span did not complete before flush',
-        });
-        span.end();
-        debug('forceFlush: ended orphaned LLM span name=%s', span.name);
-      } catch (err) {
-        debug('forceFlush: failed to end orphan span: %s', err?.message || err);
-      }
-    }
-  }
-
-  shutdown() {
-    return this._delegate.shutdown();
-  }
-}
-
-module.exports = { CONTENT_CAPTURE_ENV, WeflayrSpanProcessor };

package/src/otel/vercel-ai-sdk-span-filter.js

@@ -1,79 +0,0 @@
-'use strict';
-
-// The Vercel AI SDK's OTel integrations emit aggregate spans around each model
-// call, all repeating the same usage counts:
-//   - `@ai-sdk/otel` (ai >= 7, scope "gen_ai"): per-call "chat" spans are
-//     wrapped in "agent_step" + "invoke_agent" spans, and embed/embedMany
-//     emits an outer "embeddings" operation span around the model-call
-//     "embeddings" span(s).
-//   - the legacy integration (ai <= 6, scope "ai"): `ai.<fn>.do<Call>` spans
-//     are wrapped in an outer `ai.<fn>` span.
-// Exactly one span per model call may reach the exporter — exporting an
-// aggregate alongside its children would bill every call twice.
-
-const VERCEL_SEMCONV_SCOPE = 'gen_ai';
-const VERCEL_LEGACY_SCOPE = 'ai';
-
-const LEGACY_MODEL_CALL_SPAN_NAME = /\.do(Generate|Stream|Embed)$/;
-
-function _parentSpanId(span) {
-  return span.parentSpanContext?.spanId ?? span.parentSpanId;
-}
-
-class VercelAiSdkSpanFilter {
-  constructor() {
-    // spanId -> gen_ai.operation.name for open "gen_ai"-scope spans, so a
-    // span can check what its parent is (children end before their parent).
-    this._openSpanOperations = new Map();
-  }
-
-  onStart(span) {
-    if (span.instrumentationScope?.name !== VERCEL_SEMCONV_SCOPE) return;
-    this._openSpanOperations.set(
-      span.spanContext().spanId,
-      span.attributes['gen_ai.operation.name']
-    );
-  }
-
-  /**
-   * Export verdict for a Vercel AI SDK span, or null when the span is not
-   * one (the caller falls back to the default filter).
-   */
-  shouldExport(span) {
-    const scope = span.instrumentationScope?.name;
-    if (scope === VERCEL_LEGACY_SCOPE) {
-      return LEGACY_MODEL_CALL_SPAN_NAME.test(span.name);
-    }
-    if (scope !== VERCEL_SEMCONV_SCOPE) {
-      return null;
-    }
-    const operation = span.attributes['gen_ai.operation.name'];
-    this._openSpanOperations.delete(span.spanContext().spanId);
-    if (operation === 'chat') {
-      return true;
-    }
-    if (operation === 'embeddings') {
-      // Keep the outer aggregate (one event per embed/embedMany call, with the
-      // total usage) and drop the nested model-call span(s) repeating it.
-      return this._openSpanOperations.get(_parentSpanId(span)) !== 'embeddings';
-    }
-    // invoke_agent / agent_step (usage aggregates) and execute_tool (no usage).
-    return false;
-  }
-}
-
-// `@ai-sdk/otel` reports the Vercel AI Gateway as the bare provider id
-// "gateway" — too generic a name to special-case downstream. Stamp the weflayr
-// provider override (which the normalizer prefers) with the canonical name.
-// A providerName set through propagateMetadata was stamped at span start and
-// wins.
-function stampVercelGatewayProviderName(span) {
-  if (
-    span.attributes['gen_ai.provider.name'] === 'gateway' &&
-    span.attributes['weflayr.provider_name'] === undefined
-  ) {
-    span.attributes['weflayr.provider_name'] = 'vercel_ai_gateway';
-  }
-}
-
-module.exports = { VercelAiSdkSpanFilter, stampVercelGatewayProviderName };