weflayr 0.23.0 → 0.26.0

package/tests/index.test.js

@@ -1,824 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const Module = require('node:module');
-
-const { trace, context: otelContext } = require('@opentelemetry/api');
-const { BasicTracerProvider } = require('@opentelemetry/sdk-trace-base');
-const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
-const { AsyncHooksContextManager } = require('@opentelemetry/context-async-hooks');
-
-const weflayr = require('../src');
-const { _state } = require('../src/setup');
-const { isDefaultExportSpan } = require('../src/otel/span-filter');
-const { WeflayrSpanProcessor } = require('../src/otel/span-processor');
-const { buildExporter, _exportWithRetry } = require('../src/otel/exporter');
-
-const contextManager = new AsyncHooksContextManager();
-contextManager.enable();
-otelContext.setGlobalContextManager(contextManager);
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-function makeExporterStub() {
-  const exported = [];
-  return {
-    exported,
-    export(spans, cb) {
-      exported.push(...spans);
-      cb({ code: 0 });
-    },
-    shutdown() {
-      return Promise.resolve();
-    },
-    forceFlush() {
-      return Promise.resolve();
-    },
-  };
-}
-
-function makeFakeSpan({
-  attributes = {},
-  instrumentationScope = { name: 'opentelemetry.instrumentation.openai' },
-  name = 'openai.chat',
-} = {}) {
-  const attrs = { ...attributes };
-  const ctx = {
-    traceId: '11111111111111111111111111111111',
-    spanId: '2222222222222222',
-    traceFlags: 1,
-  };
-  return {
-    name,
-    attributes: attrs,
-    instrumentationScope,
-    instrumentationLibrary: instrumentationScope,
-    resource: { attributes: {} },
-    kind: 0,
-    status: { code: 0 },
-    startTime: [0, 0],
-    endTime: [0, 0],
-    duration: [0, 0],
-    events: [],
-    links: [],
-    droppedAttributesCount: 0,
-    droppedEventsCount: 0,
-    droppedLinksCount: 0,
-    ended: true,
-    spanContext: () => ctx,
-    setAttribute(k, v) {
-      attrs[k] = v;
-    },
-    setAttributes(obj) {
-      Object.assign(attrs, obj);
-    },
-    isRecording: () => true,
-  };
-}
-
-// ── setup ─────────────────────────────────────────────────────────────────────
-
-test('setup throws without apiKey', () => {
-  const saved = process.env.WEFLAYR_API_KEY;
-  delete process.env.WEFLAYR_API_KEY;
-  try {
-    assert.throws(() => weflayr.setup({}), /apiKey/);
-  } finally {
-    if (saved !== undefined) process.env.WEFLAYR_API_KEY = saved;
-  }
-});
-
-test('setup picks up apiKey from WEFLAYR_API_KEY env var', () => {
-  trace.disable();
-  _state.processor = null;
-  process.env.WEFLAYR_API_KEY = 'env-key';
-  try {
-    weflayr.setup({});
-    assert.ok(_state.processor, 'processor must be installed using the env-var key');
-  } finally {
-    delete process.env.WEFLAYR_API_KEY;
-  }
-});
-
-test('setup sets the content-capture env var when captureMessageContent=false', () => {
-  delete process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT;
-  weflayr.setup({ apiKey: 'test-key', captureMessageContent: false });
-  assert.equal(process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, 'false');
-});
-
-test('setup with captureMessageContent=true sets env var to true', () => {
-  delete process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT;
-  weflayr.setup({ apiKey: 'test-key', captureMessageContent: true });
-  assert.equal(process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, 'true');
-});
-
-test('setup without captureMessageContent leaves env var untouched', () => {
-  delete process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT;
-  weflayr.setup({ apiKey: 'test-key' });
-  assert.equal(process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, undefined);
-});
-
-test('setup adopts a pre-existing TracerProvider', () => {
-  // Reset the global proxy and our _state so the test owns the registry.
-  trace.disable();
-  _state.processor = null;
-
-  // The user (or another OTel instrumentation) registers a provider first.
-  const foreign = new NodeTracerProvider({ spanProcessors: [] });
-  foreign.register();
-
-  weflayr.setup({ apiKey: 'test-key' });
-
-  // weflayr must have attached its processor to `foreign`, not created a new
-  // provider — otherwise provider.register() would have silently no-op'd and
-  // the LLM spans wouldn't reach our exporter.
-  const attached = foreign._activeSpanProcessor?._spanProcessors ?? [];
-  assert.ok(
-    attached.some((sp) => sp instanceof WeflayrSpanProcessor),
-    'WeflayrSpanProcessor must be attached to the existing TracerProvider'
-  );
-  assert.strictEqual(_state.tracerProvider, foreign);
-});
-
-test('setup called twice replaces the prior processor', () => {
-  // Stacking would double-export every span and leak HTTP pools in
-  // long-running processes that reconfigure (e.g. API-key rotation).
-  trace.disable();
-  _state.processor = null;
-
-  weflayr.setup({ apiKey: 'k1' });
-  const firstProcessor = _state.processor;
-  let shutdownCalled = false;
-  const originalShutdown = firstProcessor.shutdown.bind(firstProcessor);
-  firstProcessor.shutdown = () => {
-    shutdownCalled = true;
-    return originalShutdown();
-  };
-
-  weflayr.setup({ apiKey: 'k2' });
-
-  assert.ok(_state.processor);
-  assert.notStrictEqual(_state.processor, firstProcessor);
-  assert.equal(shutdownCalled, true);
-
-  const tp = _state.tracerProvider;
-  const attached = tp._activeSpanProcessor?._spanProcessors ?? [];
-  assert.ok(!attached.includes(firstProcessor));
-  assert.ok(attached.includes(_state.processor));
-});
-
-// ── buildExporter ─────────────────────────────────────────────────────────────
-
-function _exporterParams(exporter) {
-  return exporter._delegate._transport._transport._parameters;
-}
-
-test('buildExporter sets the bearer header and base URL', () => {
-  const exporter = buildExporter({ baseUrl: 'https://api.weflayr.com', apiKey: 'sk-x' });
-  assert.equal(_exporterParams(exporter).url, 'https://api.weflayr.com/');
-});
-
-test('buildExporter strips trailing slash on baseUrl', () => {
-  const exporter = buildExporter({ baseUrl: 'https://api.weflayr.com/', apiKey: 'k' });
-  assert.equal(_exporterParams(exporter).url, 'https://api.weflayr.com/');
-});
-
-test('buildExporter warns on every export error when warnOnExportError is true', async () => {
-  const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
-  const origExport = OTLPTraceExporter.prototype.export;
-  OTLPTraceExporter.prototype.export = function (spans, cb) {
-    cb({ code: 1, error: { code: 401, message: 'Unauthorized' } });
-  };
-  const warnings = [];
-  const origWarn = console.warn;
-  console.warn = (...args) => warnings.push(args.join(' '));
-  try {
-    const exporter = buildExporter({
-      baseUrl: 'https://api.weflayr.com',
-      apiKey: 'bad',
-      warnOnExportError: true,
-    });
-    await new Promise((resolve) => exporter.export([], resolve));
-    await new Promise((resolve) => exporter.export([], resolve));
-    assert.equal(warnings.filter((w) => w.includes('[weflayr]')).length, 2);
-  } finally {
-    OTLPTraceExporter.prototype.export = origExport;
-    console.warn = origWarn;
-  }
-});
-
-test('buildExporter does not warn when warnOnExportError is false', async () => {
-  const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
-  const origExport = OTLPTraceExporter.prototype.export;
-  OTLPTraceExporter.prototype.export = function (spans, cb) {
-    cb({ code: 1, error: { code: 401, message: 'Unauthorized' } });
-  };
-  const warnings = [];
-  const origWarn = console.warn;
-  console.warn = (...args) => warnings.push(args.join(' '));
-  try {
-    const exporter = buildExporter({
-      baseUrl: 'https://api.weflayr.com',
-      apiKey: 'bad',
-      warnOnExportError: false,
-    });
-    await new Promise((resolve) => exporter.export([], resolve));
-    await new Promise((resolve) => exporter.export([], resolve));
-    assert.equal(warnings.filter((w) => w.includes('[weflayr]')).length, 0);
-  } finally {
-    OTLPTraceExporter.prototype.export = origExport;
-    console.warn = origWarn;
-  }
-});
-
-// ── span-filter ───────────────────────────────────────────────────────────────
-
-test('isDefaultExportSpan accepts spans with gen_ai.* attributes', () => {
-  const span = makeFakeSpan({
-    attributes: { 'gen_ai.system': 'openai' },
-    instrumentationScope: { name: 'unknown' },
-  });
-  assert.equal(isDefaultExportSpan(span), true);
-});
-
-test('isDefaultExportSpan accepts spans from known instrumentation scopes', () => {
-  const span = makeFakeSpan({
-    attributes: {},
-    instrumentationScope: { name: 'opentelemetry.instrumentation.openai' },
-  });
-  assert.equal(isDefaultExportSpan(span), true);
-});
-
-test('isDefaultExportSpan rejects unrelated spans', () => {
-  const span = makeFakeSpan({
-    attributes: { 'http.method': 'GET' },
-    instrumentationScope: { name: 'http' },
-  });
-  assert.equal(isDefaultExportSpan(span), false);
-});
-
-// ── WeflayrSpanProcessor ──────────────────────────────────────────────────────
-
-test('WeflayrSpanProcessor stamps defaultTags on span start', () => {
-  const exporter = makeExporterStub();
-  const proc = new WeflayrSpanProcessor({
-    exporter,
-    defaultTags: { app: 'svc-A', env: 'prod' },
-  });
-  const span = makeFakeSpan();
-  proc.onStart(span, otelContext.active());
-  assert.equal(span.attributes['weflayr.tag.app'], 'svc-A');
-  assert.equal(span.attributes['weflayr.tag.env'], 'prod');
-});
-
-test('WeflayrSpanProcessor forwards GenAI spans to the exporter', async () => {
-  const exporter = makeExporterStub();
-  const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
-  const span = makeFakeSpan({ attributes: { 'gen_ai.system': 'openai' } });
-  proc.onEnd(span);
-  await proc.forceFlush();
-  assert.equal(exporter.exported.length, 1);
-});
-
-test('WeflayrSpanProcessor drops non-GenAI spans', async () => {
-  const exporter = makeExporterStub();
-  const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
-  proc.onEnd(
-    makeFakeSpan({
-      attributes: { 'http.method': 'GET' },
-      instrumentationScope: { name: 'http' },
-    })
-  );
-  await proc.forceFlush();
-  assert.equal(exporter.exported.length, 0);
-});
-
-test('WeflayrSpanProcessor ends orphaned LLM spans on forceFlush', async () => {
-  // LLM spans that started but never ended should be force-ended with ERROR on
-  // flush — covers openllmetry-style leaks (e.g. anthropic streaming auth error).
-  const exporter = makeExporterStub();
-  const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
-  const provider = new BasicTracerProvider({ spanProcessors: [proc] });
-  const tracer = provider.getTracer('opentelemetry.instrumentation.anthropic');
-
-  const leaked = tracer.startSpan('anthropic.chat');
-  leaked.setAttribute('gen_ai.system', 'anthropic');
-  assert.equal(exporter.exported.length, 0, 'span should not have been exported yet');
-
-  await proc.forceFlush();
-
-  assert.equal(exporter.exported.length, 1);
-  // SpanStatusCode.ERROR === 2 in @opentelemetry/api
-  assert.equal(exporter.exported[0].status.code, 2);
-  await provider.shutdown();
-});
-
-test('WeflayrSpanProcessor applies mask before export', async () => {
-  const exporter = makeExporterStub();
-  let received = null;
-  const proc = new WeflayrSpanProcessor({
-    exporter,
-    exportMode: 'immediate',
-    mask: (attrs) => {
-      received = attrs;
-      attrs['gen_ai.prompt'] = '[REDACTED]';
-      return attrs;
-    },
-  });
-  const span = makeFakeSpan({
-    attributes: { 'gen_ai.system': 'openai', 'gen_ai.prompt': 'Hi Noe' },
-  });
-  proc.onEnd(span);
-  await proc.forceFlush();
-  assert.ok(received);
-  assert.equal(span.attributes['gen_ai.prompt'], '[REDACTED]');
-});
-
-test('WeflayrSpanProcessor strips message content when capture disabled', async () => {
-  // Instrumentors gate content on their own env vars (openllmetry captures by
-  // default), so the processor itself must drop message content when
-  // captureMessageContent=false recorded "false" in the env var.
-  process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = 'false';
-  try {
-    const exporter = makeExporterStub();
-    const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
-    const span = makeFakeSpan({
-      attributes: {
-        'gen_ai.system': 'openai',
-        'gen_ai.input.messages': '[{"role": "user"}]',
-        'gen_ai.output.messages': '[{"role": "assistant"}]',
-        'gen_ai.system_instructions': '[{"type": "text"}]',
-        'gen_ai.prompt.0.content': 'Hi Noe',
-        'gen_ai.completion.0.content': 'Hello!',
-        'gen_ai.usage.input_tokens': 12,
-      },
-    });
-    proc.onEnd(span);
-    await proc.forceFlush();
-    assert.equal(span.attributes['gen_ai.system'], 'openai');
-    assert.equal(span.attributes['gen_ai.usage.input_tokens'], 12);
-    for (const key of Object.keys(span.attributes)) {
-      assert.ok(!key.startsWith('gen_ai.prompt'), `unexpected ${key}`);
-      assert.ok(!key.startsWith('gen_ai.completion'), `unexpected ${key}`);
-    }
-    assert.ok(!('gen_ai.input.messages' in span.attributes));
-    assert.ok(!('gen_ai.output.messages' in span.attributes));
-    assert.ok(!('gen_ai.system_instructions' in span.attributes));
-  } finally {
-    delete process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT;
-  }
-});
-
-test('WeflayrSpanProcessor keeps message content when capture enabled', async () => {
-  process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = 'true';
-  try {
-    const exporter = makeExporterStub();
-    const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
-    const span = makeFakeSpan({
-      attributes: {
-        'gen_ai.system': 'openai',
-        'gen_ai.input.messages': '[{"role": "user"}]',
-      },
-    });
-    proc.onEnd(span);
-    await proc.forceFlush();
-    assert.equal(span.attributes['gen_ai.input.messages'], '[{"role": "user"}]');
-  } finally {
-    delete process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT;
-  }
-});
-
-// ── propagateMetadata ────────────────────────────────────────────────────────
-
-function _makeMetadataHarness() {
-  const exporter = makeExporterStub();
-  const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
-  const provider = new BasicTracerProvider({ spanProcessors: [proc] });
-  const tracer = provider.getTracer('test');
-  return { exporter, proc, provider, tracer };
-}
-
-test('propagateMetadata writes structured fields and extra tags', async () => {
-  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
-
-  await weflayr.propagateMetadata(
-    {
-      featureName: 'onboarding',
-      customerName: '#3756',
-      extraTags: { variant: 'control' },
-    },
-    async () => {
-      const span = tracer.startSpan('child');
-      span.setAttribute('gen_ai.system', 'openai');
-      span.end();
-    }
-  );
-
-  await proc.forceFlush();
-  assert.equal(exporter.exported.length, 1);
-  const attrs = exporter.exported[0].attributes;
-  assert.equal(attrs['weflayr.feature_name'], 'onboarding');
-  assert.equal(attrs['weflayr.customer_name'], '#3756');
-  assert.equal(attrs['weflayr.tag.variant'], 'control');
-  assert.ok(attrs['weflayr.uuid']);
-  assert.equal(attrs['weflayr.provider_name'], undefined);
-  await provider.shutdown();
-});
-
-test('propagateMetadata uuid is stable within scope and changes across calls', async () => {
-  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
-
-  await weflayr.propagateMetadata({ featureName: 'f', customerName: 'c' }, async () => {
-    const spanA = tracer.startSpan('a');
-    spanA.setAttribute('gen_ai.system', 'openai');
-    spanA.end();
-    const spanB = tracer.startSpan('b');
-    spanB.setAttribute('gen_ai.system', 'openai');
-    spanB.end();
-  });
-
-  await weflayr.propagateMetadata({ featureName: 'f', customerName: 'c' }, async () => {
-    const spanC = tracer.startSpan('c_span');
-    spanC.setAttribute('gen_ai.system', 'openai');
-    spanC.end();
-  });
-
-  await proc.forceFlush();
-  const uuidA = exporter.exported[0].attributes['weflayr.uuid'];
-  const uuidB = exporter.exported[1].attributes['weflayr.uuid'];
-  const uuidC = exporter.exported[2].attributes['weflayr.uuid'];
-  assert.equal(uuidA, uuidB);
-  assert.notEqual(uuidA, uuidC);
-  await provider.shutdown();
-});
-
-test('propagateMetadata nested scopes inner overrides and extra tags merge', async () => {
-  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
-
-  await weflayr.propagateMetadata(
-    {
-      featureName: 'outer',
-      customerName: 'outer_c',
-      extraTags: { variant: 'A', shared: 'outer' },
-    },
-    async () => {
-      await weflayr.propagateMetadata(
-        {
-          featureName: 'inner',
-          customerName: 'inner_c',
-          extraTags: { shared: 'inner', experiment: 'B' },
-        },
-        async () => {
-          const span = tracer.startSpan('child');
-          span.setAttribute('gen_ai.system', 'openai');
-          span.end();
-        }
-      );
-    }
-  );
-
-  await proc.forceFlush();
-  const attrs = exporter.exported[0].attributes;
-  assert.equal(attrs['weflayr.feature_name'], 'inner');
-  assert.equal(attrs['weflayr.customer_name'], 'inner_c');
-  // Outer extra tag not shadowed survives
-  assert.equal(attrs['weflayr.tag.variant'], 'A');
-  // Inner extra tag wins on conflict
-  assert.equal(attrs['weflayr.tag.shared'], 'inner');
-  assert.equal(attrs['weflayr.tag.experiment'], 'B');
-  await provider.shutdown();
-});
-
-test('propagateMetadata decorator mints fresh uuid per invocation', async () => {
-  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
-
-  const wrap = weflayr.propagateMetadata({ featureName: 'f', customerName: 'c' });
-  const leaf = wrap(async function leaf() {
-    const span = tracer.startSpan('child');
-    span.setAttribute('gen_ai.system', 'openai');
-    span.end();
-  });
-
-  await leaf();
-  await leaf();
-
-  await proc.forceFlush();
-  const uuidFirst = exporter.exported[0].attributes['weflayr.uuid'];
-  const uuidSecond = exporter.exported[1].attributes['weflayr.uuid'];
-  assert.notEqual(uuidFirst, uuidSecond);
-  await provider.shutdown();
-});
-
-test('propagateMetadata decorator form wraps a function', async () => {
-  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
-
-  const wrap = weflayr.propagateMetadata({
-    featureName: 'chat',
-    customerName: 'c_42',
-    extraTags: { experiment: 'B' },
-  });
-  const leaf = wrap(async function leaf() {
-    const span = tracer.startSpan('child');
-    span.setAttribute('gen_ai.system', 'openai');
-    span.end();
-  });
-
-  await leaf();
-  await proc.forceFlush();
-  const attrs = exporter.exported[0].attributes;
-  assert.equal(attrs['weflayr.feature_name'], 'chat');
-  assert.equal(attrs['weflayr.customer_name'], 'c_42');
-  assert.equal(attrs['weflayr.tag.experiment'], 'B');
-  await provider.shutdown();
-});
-
-test('propagateMetadata callable form runs function', async () => {
-  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
-
-  const result = await weflayr.propagateMetadata(
-    {
-      featureName: 'callable',
-      customerName: 'c_42',
-      extraTags: { variant: 'A' },
-    },
-    async () => {
-      const span = tracer.startSpan('child');
-      span.setAttribute('gen_ai.system', 'openai');
-      span.end();
-      return 'done';
-    }
-  );
-
-  await proc.forceFlush();
-  assert.equal(result, 'done');
-  const attrs = exporter.exported[0].attributes;
-  assert.equal(attrs['weflayr.feature_name'], 'callable');
-  assert.equal(attrs['weflayr.tag.variant'], 'A');
-  await provider.shutdown();
-});
-
-test('propagateMetadata providerName writes attribute', async () => {
-  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
-
-  await weflayr.propagateMetadata(
-    {
-      featureName: 'f',
-      customerName: 'c',
-      providerName: weflayr.AIProviderName.VERCEL_AI_GATEWAY,
-    },
-    async () => {
-      const span = tracer.startSpan('child');
-      span.setAttribute('gen_ai.system', 'openai');
-      span.end();
-    }
-  );
-
-  await proc.forceFlush();
-  assert.equal(exporter.exported[0].attributes['weflayr.provider_name'], 'vercel_ai_gateway');
-  await provider.shutdown();
-});
-
-test('propagateMetadata requires featureName and customerName', () => {
-  assert.throws(() => weflayr.propagateMetadata({}), /featureName.*customerName.*required/);
-  assert.throws(() => weflayr.propagateMetadata({ featureName: 'f' }), /required/);
-  assert.throws(() => weflayr.propagateMetadata({ customerName: 'c' }), /required/);
-});
-
-test('propagateMetadata deprecated customerId still works', async () => {
-  const { exporter, proc, provider, tracer } = _makeMetadataHarness();
-
-  const warnings = [];
-  const onWarning = (warning) => warnings.push(warning);
-  process.on('warning', onWarning);
-
-  await weflayr.propagateMetadata({ featureName: 'f', customerId: 'Acme Corp' }, async () => {
-    const span = tracer.startSpan('child');
-    span.setAttribute('gen_ai.system', 'openai');
-    span.end();
-  });
-
-  // process.emitWarning delivers on a later tick; drain it before asserting.
-  await new Promise((resolve) => process.nextTick(resolve));
-  process.removeListener('warning', onWarning);
-  assert.ok(warnings.some((warning) => /customerId.*deprecated/.test(warning.message)));
-
-  await proc.forceFlush();
-  const attrs = exporter.exported[0].attributes;
-  assert.equal(attrs['weflayr.customer_name'], 'Acme Corp');
-  await provider.shutdown();
-});
-
-// ── autoInstrument ────────────────────────────────────────────────────────────
-
-function _ensureSetupDone() {
-  if (!_state.processor) weflayr.setup({ apiKey: 'test-key' });
-}
-
-// Instrumenting OPENAI also runs the bundled audio + embeddings instrumentors,
-// which eagerly require the openai resource modules. Stub them so autoInstrument
-// tests don't need the real `openai` dependency installed.
-const OPENAI_RESOURCE_STUBS = {
-  'openai/resources/audio/speech': {
-    Speech: class {
-      create() {}
-    },
-  },
-  'openai/resources/audio/transcriptions': {
-    Transcriptions: class {
-      create() {}
-    },
-  },
-  'openai/resources/embeddings': {
-    Embeddings: class {
-      create() {}
-    },
-  },
-};
-
-function _stubOpenAIResources() {
-  for (const [id, exports] of Object.entries(OPENAI_RESOURCE_STUBS)) {
-    require.cache[id] = { id, filename: id, loaded: true, exports };
-  }
-  return () => {
-    for (const id of Object.keys(OPENAI_RESOURCE_STUBS)) delete require.cache[id];
-  };
-}
-
-test('autoInstrument throws "install package X" when the dep is missing', async () => {
-  _ensureSetupDone();
-  await assert.rejects(
-    () => weflayr.autoInstrument({ aiSdks: weflayr.AiSdk.OPENAI }),
-    /Install it with: npm install @traceloop\/instrumentation-openai/
-  );
-});
-
-test('autoInstrument rejects unknown providers', async () => {
-  // JS keeps this runtime check because `AiSdk` is a frozen object — it
-  // doesn't enforce membership at the value level the way Python's `Enum` does.
-  _ensureSetupDone();
-  await assert.rejects(() => weflayr.autoInstrument({ aiSdks: 'unicorn-llm' }), /unknown provider/);
-});
-
-test('autoInstrument loads a stubbed Traceloop package', async () => {
-  _ensureSetupDone();
-  let constructed = false;
-  class FakeOpenAIInstrumentation {
-    constructor() {
-      constructed = true;
-    }
-    enable() {}
-    disable() {}
-    setTracerProvider() {}
-    setMeterProvider() {}
-    setConfig() {}
-    getConfig() {
-      return {};
-    }
-  }
-  const origResolve = Module._resolveFilename;
-  Module._resolveFilename = function patched(req, ...rest) {
-    if (req === '@traceloop/instrumentation-openai' || req in OPENAI_RESOURCE_STUBS) return req;
-    return origResolve.call(this, req, ...rest);
-  };
-  require.cache['@traceloop/instrumentation-openai'] = {
-    id: '@traceloop/instrumentation-openai',
-    filename: '@traceloop/instrumentation-openai',
-    loaded: true,
-    exports: { OpenAIInstrumentation: FakeOpenAIInstrumentation },
-  };
-  const cleanupOpenAI = _stubOpenAIResources();
-  try {
-    await weflayr.autoInstrument({ aiSdks: weflayr.AiSdk.OPENAI });
-    assert.equal(constructed, true);
-  } finally {
-    Module._resolveFilename = origResolve;
-    delete require.cache['@traceloop/instrumentation-openai'];
-    cleanupOpenAI();
-  }
-});
-
-test('autoInstrument throws when no apiKey is reachable (env nor argument)', async () => {
-  _state.processor = null;
-  const saved = process.env.WEFLAYR_API_KEY;
-  delete process.env.WEFLAYR_API_KEY;
-  try {
-    await assert.rejects(
-      () => weflayr.autoInstrument({ aiSdks: weflayr.AiSdk.OPENAI }),
-      /apiKey.*required/
-    );
-  } finally {
-    if (saved !== undefined) process.env.WEFLAYR_API_KEY = saved;
-  }
-});
-
-test('autoInstrument with an empty aiSdks list still runs setup', async () => {
-  // The vercel instrumentor's ai <= 6 error message tells users to keep their
-  // autoInstrument call with 'vercel_ai_gateway' removed (possibly leaving an
-  // empty list) — that must still install the processor.
-  _state.processor = null;
-  await weflayr.autoInstrument({ aiSdks: [], apiKey: 'empty-list-key' });
-  assert.ok(_state.processor, 'processor should be installed by the embedded setup() call');
-});
-
-test('autoInstrument runs setup when apiKey passed', async () => {
-  _state.processor = null;
-  class FakeOpenAIInstrumentation {
-    constructor() {}
-    enable() {}
-    disable() {}
-    setTracerProvider() {}
-    setMeterProvider() {}
-    setConfig() {}
-    getConfig() {
-      return {};
-    }
-  }
-  const origResolve = Module._resolveFilename;
-  Module._resolveFilename = function patched(req, ...rest) {
-    if (req === '@traceloop/instrumentation-openai' || req in OPENAI_RESOURCE_STUBS) return req;
-    return origResolve.call(this, req, ...rest);
-  };
-  require.cache['@traceloop/instrumentation-openai'] = {
-    id: '@traceloop/instrumentation-openai',
-    filename: '@traceloop/instrumentation-openai',
-    loaded: true,
-    exports: { OpenAIInstrumentation: FakeOpenAIInstrumentation },
-  };
-  const cleanupOpenAI = _stubOpenAIResources();
-  try {
-    await weflayr.autoInstrument({
-      aiSdks: weflayr.AiSdk.OPENAI,
-      apiKey: 'convenience-key',
-    });
-    assert.ok(_state.processor, 'processor should be installed by the embedded setup() call');
-  } finally {
-    Module._resolveFilename = origResolve;
-    delete require.cache['@traceloop/instrumentation-openai'];
-    cleanupOpenAI();
-  }
-});
-
-test('autoInstrument requires aiSdks', async () => {
-  _state.processor = null;
-  await assert.rejects(() => weflayr.autoInstrument({ apiKey: 'k' }), /`aiSdks` is required/);
-});
-
-// ── exporter retry ────────────────────────────────────────────────────────────
-
-function _failResult(status) {
-  return { code: 1, error: { code: status, message: `HTTP ${status}` } };
-}
-
-test('exporter retries on 503 then succeeds', async () => {
-  const responses = [_failResult(503), _failResult(503), { code: 0 }];
-  let i = 0;
-  const fakeExport = (spans, cb) => cb(responses[i++]);
-  const wrapped = _exportWithRetry(fakeExport, { maxRetries: 3, maxRetryMs: 5000 });
-  const result = await new Promise((resolve) => wrapped([], resolve));
-  assert.equal(result.code, 0);
-  assert.equal(i, 3);
-});
-
-test('exporter does not retry on 401', async () => {
-  let calls = 0;
-  const fakeExport = (spans, cb) => {
-    calls++;
-    cb(_failResult(401));
-  };
-  const wrapped = _exportWithRetry(fakeExport, { maxRetries: 3, maxRetryMs: 5000 });
-  const result = await new Promise((resolve) => wrapped([], resolve));
-  assert.equal(result.code, 1);
-  assert.equal(result.error.code, 401);
-  assert.equal(calls, 1);
-});
-
-test('exporter swallows unexpected exceptions', async () => {
-  const fakeExport = () => {
-    throw new Error('boom');
-  };
-  const wrapped = _exportWithRetry(fakeExport, { maxRetries: 1, maxRetryMs: 5000 });
-  const result = await new Promise((resolve) => wrapped([], resolve));
-  assert.equal(result.code, 1);
-});
-
-test('exporter gives up after maxRetries on persistent 503', async () => {
-  let calls = 0;
-  const fakeExport = (spans, cb) => {
-    calls++;
-    cb(_failResult(503));
-  };
-  const wrapped = _exportWithRetry(fakeExport, { maxRetries: 3, maxRetryMs: 5000 });
-  const result = await new Promise((resolve) => wrapped([], resolve));
-  assert.equal(result.code, 1);
-  assert.equal(result.error.code, 503);
-  assert.equal(calls, 3);
-});
-
-// ── flush ─────────────────────────────────────────────────────────────────────
-
-test('flush does not throw', async () => {
-  await weflayr.flush();
-});
-
-void trace;