weflayr 0.22.0 → 0.22.1

package/tests/api/index.test.js

@@ -0,0 +1,330 @@
+'use strict';
+
+// Tests for the public-API client: auth and base-URL wiring of the
+// client facade, plus the request/response wiring of every generated
+// endpoint (server behavior is covered by the dashboard's app_api tests).
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('node:http');
+
+const weflayr = require('../../src/index');
+const { api } = weflayr;
+
+// A client whose server records requests and returns a canned response.
+async function withClientReturning(responseBody, statusCode, run, clientOptions = {}) {
+  const seenRequests = [];
+  const server = http.createServer((request, response) => {
+    let requestBody = '';
+    request.on('data', (chunk) => {
+      requestBody += chunk;
+    });
+    request.on('end', () => {
+      seenRequests.push({
+        method: request.method,
+        url: request.url,
+        authorization: request.headers.authorization,
+        body: requestBody === '' ? null : JSON.parse(requestBody),
+      });
+      response.statusCode = statusCode;
+      response.setHeader('content-type', 'application/json');
+      response.end(JSON.stringify(responseBody));
+    });
+  });
+  await new Promise((resolve) => server.listen(0, resolve));
+  const client = api.client({
+    apiKey: 'wf-test-key',
+    ...clientOptions,
+    baseUrl: `http://127.0.0.1:${server.address().port}/api`,
+  });
+  try {
+    await run(client, seenRequests);
+  } finally {
+    server.close();
+  }
+}
+
+// ── client facade ─────────────────────────────────────────────────────────
+
+test('client sends the bearer key to the configured host', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    const { data } = await api.getAllRevenue({ client, throwOnError: true });
+    assert.deepEqual(data, { rows: [] });
+    assert.deepEqual(seenRequests, [
+      { method: 'GET', url: '/api/revenue/', authorization: 'Bearer wf-test-key', body: null },
+    ]);
+  });
+});
+
+test('weflayr.client is the same function as api.client', () => {
+  assert.equal(weflayr.client, api.client);
+});
+
+test('client defaults to the production API host', () => {
+  const client = api.client({ apiKey: 'wf-test-key' });
+  assert.equal(client.getConfig().baseUrl, 'https://app.weflayr.com/api');
+});
+
+test('client throws without apiKey', () => {
+  const saved = process.env.WEFLAYR_API_KEY;
+  delete process.env.WEFLAYR_API_KEY;
+  try {
+    assert.throws(() => api.client(), /apiKey/);
+  } finally {
+    if (saved !== undefined) process.env.WEFLAYR_API_KEY = saved;
+  }
+});
+
+test('client picks up apiKey from WEFLAYR_API_KEY env var', async () => {
+  process.env.WEFLAYR_API_KEY = 'env-key';
+  try {
+    await withClientReturning(
+      { rows: [] },
+      200,
+      async (client, seenRequests) => {
+        await api.getAllRevenue({ client, throwOnError: true });
+        assert.equal(seenRequests[0].authorization, 'Bearer env-key');
+      },
+      { apiKey: undefined }
+    );
+  } finally {
+    delete process.env.WEFLAYR_API_KEY;
+  }
+});
+
+// ── Revenue ───────────────────────────────────────────────────────────────────
+
+test('setRevenue posts the rows in snake_case and parses the booked count', async () => {
+  await withClientReturning({ ok: true, rows_inserted: 2 }, 200, async (client, seenRequests) => {
+    const rows = [
+      { customerName: 'c_1', amount: '1200.50', month: '2026-06' },
+      { customerName: 'c_2', amount: '800', month: '2026-06' },
+    ];
+    const { data } = await api.setRevenue({ client, throwOnError: true, body: { rows } });
+    assert.deepEqual(data, { ok: true, rowsInserted: 2 });
+    const request = seenRequests[0];
+    assert.equal(request.method, 'POST');
+    assert.equal(request.url, '/api/revenue/');
+    assert.deepEqual(request.body, {
+      rows: [
+        { customer_name: 'c_1', amount: '1200.50', month: '2026-06' },
+        { customer_name: 'c_2', amount: '800', month: '2026-06' },
+      ],
+    });
+  });
+});
+
+test('getAllRevenue parses the returned rows into camelCase', async () => {
+  const wireRow = {
+    customer_name: 'c_1',
+    metric_name: 'revenue',
+    month: '2026-06',
+    amount: '1200.50000000',
+    source: 'api',
+  };
+  await withClientReturning({ rows: [wireRow] }, 200, async (client) => {
+    const { data } = await api.getAllRevenue({ client, throwOnError: true });
+    assert.deepEqual(data.rows, [
+      {
+        customerName: 'c_1',
+        metricName: 'revenue',
+        month: '2026-06',
+        amount: '1200.50000000',
+        source: 'api',
+      },
+    ]);
+  });
+});
+
+test('getCustomerRevenue requests the customer path', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    const { data } = await api.getCustomerRevenue({
+      client,
+      throwOnError: true,
+      path: { customerName: 'c_1' },
+    });
+    assert.deepEqual(data, { rows: [] });
+    assert.equal(seenRequests[0].url, '/api/revenue/c_1/');
+  });
+});
+
+test('getCustomerRevenue surfaces a 404 and its error', async () => {
+  const rejection = { error: 'No revenue for this customer.' };
+  await withClientReturning(rejection, 404, async (client) => {
+    const { error, response } = await api.getCustomerRevenue({
+      client,
+      path: { customerName: 'nobody' },
+    });
+    assert.equal(response.status, 404);
+    assert.deepEqual(error, rejection);
+  });
+});
+
+test('deleteCustomerRevenue parses the deleted count', async () => {
+  await withClientReturning({ ok: true, rows_deleted: 1 }, 200, async (client, seenRequests) => {
+    const { data } = await api.deleteCustomerRevenue({
+      client,
+      throwOnError: true,
+      path: { customerName: 'c_1' },
+    });
+    assert.deepEqual(data, { ok: true, rowsDeleted: 1 });
+    const request = seenRequests[0];
+    assert.equal(request.method, 'DELETE');
+    assert.equal(request.url, '/api/revenue/c_1/');
+  });
+});
+
+// ── Key metrics ───────────────────────────────────────────────────────────────
+
+test('setKeyMetrics posts the rows in snake_case and parses the booked count', async () => {
+  await withClientReturning({ ok: true, rows_inserted: 1 }, 200, async (client, seenRequests) => {
+    const rows = [
+      { userName: 'u_1', metricName: 'Meetings booked', amount: '3', month: '2026-06' },
+    ];
+    const { data } = await api.setKeyMetrics({ client, throwOnError: true, body: { rows } });
+    assert.deepEqual(data, { ok: true, rowsInserted: 1 });
+    const request = seenRequests[0];
+    assert.equal(request.method, 'POST');
+    assert.equal(request.url, '/api/key-metrics/');
+    assert.deepEqual(request.body, {
+      rows: [{ user_name: 'u_1', metric_name: 'Meetings booked', amount: '3', month: '2026-06' }],
+    });
+  });
+});
+
+test('getAllKeyMetrics parses the returned rows into camelCase', async () => {
+  const wireRow = {
+    user_name: 'u_1',
+    metric_name: 'Meetings booked',
+    month: '2026-06',
+    amount: '3.00000000',
+    source: 'api',
+  };
+  await withClientReturning({ rows: [wireRow] }, 200, async (client) => {
+    const { data } = await api.getAllKeyMetrics({ client, throwOnError: true });
+    assert.deepEqual(data.rows, [
+      {
+        userName: 'u_1',
+        metricName: 'Meetings booked',
+        month: '2026-06',
+        amount: '3.00000000',
+        source: 'api',
+      },
+    ]);
+  });
+});
+
+test('getUserKeyMetrics requests the user path', async () => {
+  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
+    const { data } = await api.getUserKeyMetrics({
+      client,
+      throwOnError: true,
+      path: { userName: 'u_1' },
+    });
+    assert.deepEqual(data, { rows: [] });
+    assert.equal(seenRequests[0].url, '/api/key-metrics/u_1/');
+  });
+});
+
+test('setKeyMetrics surfaces a 422 and its details', async () => {
+  const rejection = {
+    error: 'Invalid payload.',
+    detail: [{ field: 'rows.0.metric_name', error: 'Unknown metric.' }],
+  };
+  await withClientReturning(rejection, 422, async (client) => {
+    const { error, response } = await api.setKeyMetrics({ client, body: { rows: [] } });
+    assert.equal(response.status, 422);
+    assert.deepEqual(error, rejection);
+  });
+});
+
+test('deleteUserKeyMetrics parses the deleted count', async () => {
+  await withClientReturning({ ok: true, rows_deleted: 1 }, 200, async (client, seenRequests) => {
+    const { data } = await api.deleteUserKeyMetrics({
+      client,
+      throwOnError: true,
+      path: { userName: 'u_1' },
+    });
+    assert.deepEqual(data, { ok: true, rowsDeleted: 1 });
+    const request = seenRequests[0];
+    assert.equal(request.method, 'DELETE');
+    assert.equal(request.url, '/api/key-metrics/u_1/');
+  });
+});
+
+// ── Customer tags ─────────────────────────────────────────────────────────────
+
+test('setCustomersTags posts the customers in snake_case and parses the updated count', async () => {
+  await withClientReturning(
+    { ok: true, customers_updated: 1 },
+    200,
+    async (client, seenRequests) => {
+      const customers = [{ customerName: 'c_1', tags: { plan: 'pro' } }];
+      const { data } = await api.setCustomersTags({
+        client,
+        throwOnError: true,
+        body: { customers },
+      });
+      assert.deepEqual(data, { ok: true, customersUpdated: 1 });
+      const request = seenRequests[0];
+      assert.equal(request.method, 'POST');
+      assert.equal(request.url, '/api/customer-tags/');
+      assert.deepEqual(request.body, {
+        customers: [{ customer_name: 'c_1', tags: { plan: 'pro' } }],
+      });
+    }
+  );
+});
+
+test('setCustomersTags leaves tag keys untouched, even when they contain underscores', async () => {
+  await withClientReturning(
+    { ok: true, customers_updated: 1 },
+    200,
+    async (client, seenRequests) => {
+      const customers = [{ customerName: 'c_1', tags: { utm_source: 'ads', plan_tier: 'pro' } }];
+      await api.setCustomersTags({ client, throwOnError: true, body: { customers } });
+      assert.deepEqual(seenRequests[0].body, {
+        customers: [{ customer_name: 'c_1', tags: { utm_source: 'ads', plan_tier: 'pro' } }],
+      });
+    }
+  );
+});
+
+test('getAllCustomersTags parses the returned customers into camelCase', async () => {
+  const wireCustomer = { customer_name: 'c_1', tags: { plan: 'pro' } };
+  await withClientReturning(
+    { customers: [wireCustomer], next_cursor: null, has_more: false },
+    200,
+    async (client) => {
+      const { data } = await api.getAllCustomersTags({ client, throwOnError: true });
+      assert.deepEqual(data.customers, [{ customerName: 'c_1', tags: { plan: 'pro' } }]);
+    }
+  );
+});
+
+test('getCustomerTags parses the customer tags, leaving tag keys untouched', async () => {
+  const wireTags = { customer_name: 'c_1', tags: { plan: 'pro', utm_source: 'ads' } };
+  await withClientReturning(wireTags, 200, async (client, seenRequests) => {
+    const { data } = await api.getCustomerTags({
+      client,
+      throwOnError: true,
+      path: { customerName: 'c_1' },
+    });
+    assert.deepEqual(data, { customerName: 'c_1', tags: { plan: 'pro', utm_source: 'ads' } });
+    assert.equal(seenRequests[0].url, '/api/customer-tags/c_1/');
+  });
+});
+
+test('deleteCustomerTags parses the deleted count', async () => {
+  await withClientReturning({ ok: true, tags_deleted: 1 }, 200, async (client, seenRequests) => {
+    const { data } = await api.deleteCustomerTags({
+      client,
+      throwOnError: true,
+      path: { customerName: 'c_1' },
+    });
+    assert.deepEqual(data, { ok: true, tagsDeleted: 1 });
+    const request = seenRequests[0];
+    assert.equal(request.method, 'DELETE');
+    assert.equal(request.url, '/api/customer-tags/c_1/');
+  });
+});

package/tests/index.test.js

@@ -405,7 +405,7 @@ test('propagateMetadata writes structured fields and extra tags', async () => {
   await weflayr.propagateMetadata(
     {
       featureName: 'onboarding',
-      customerId: '#3756',
+      customerName: '#3756',
       extraTags: { variant: 'control' },
     },
     async () => {
@@ -419,7 +419,7 @@ test('propagateMetadata writes structured fields and extra tags', async () => {
   assert.equal(exporter.exported.length, 1);
   const attrs = exporter.exported[0].attributes;
   assert.equal(attrs['weflayr.feature_name'], 'onboarding');
-  assert.equal(attrs['weflayr.customer_id'], '#3756');
+  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);
@@ -429,7 +429,7 @@ test('propagateMetadata writes structured fields and extra tags', async () => {
 test('propagateMetadata uuid is stable within scope and changes across calls', async () => {
   const { exporter, proc, provider, tracer } = _makeMetadataHarness();
 
-  await weflayr.propagateMetadata({ featureName: 'f', customerId: 'c' }, async () => {
+  await weflayr.propagateMetadata({ featureName: 'f', customerName: 'c' }, async () => {
     const spanA = tracer.startSpan('a');
     spanA.setAttribute('gen_ai.system', 'openai');
     spanA.end();
@@ -438,7 +438,7 @@ test('propagateMetadata uuid is stable within scope and changes across calls', a
     spanB.end();
   });
 
-  await weflayr.propagateMetadata({ featureName: 'f', customerId: 'c' }, async () => {
+  await weflayr.propagateMetadata({ featureName: 'f', customerName: 'c' }, async () => {
     const spanC = tracer.startSpan('c_span');
     spanC.setAttribute('gen_ai.system', 'openai');
     spanC.end();
@@ -459,14 +459,14 @@ test('propagateMetadata nested scopes inner overrides and extra tags merge', asy
   await weflayr.propagateMetadata(
     {
       featureName: 'outer',
-      customerId: 'outer_c',
+      customerName: 'outer_c',
       extraTags: { variant: 'A', shared: 'outer' },
     },
     async () => {
       await weflayr.propagateMetadata(
         {
           featureName: 'inner',
-          customerId: 'inner_c',
+          customerName: 'inner_c',
           extraTags: { shared: 'inner', experiment: 'B' },
         },
         async () => {
@@ -481,7 +481,7 @@ test('propagateMetadata nested scopes inner overrides and extra tags merge', asy
   await proc.forceFlush();
   const attrs = exporter.exported[0].attributes;
   assert.equal(attrs['weflayr.feature_name'], 'inner');
-  assert.equal(attrs['weflayr.customer_id'], 'inner_c');
+  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
@@ -493,7 +493,7 @@ test('propagateMetadata nested scopes inner overrides and extra tags merge', asy
 test('propagateMetadata decorator mints fresh uuid per invocation', async () => {
   const { exporter, proc, provider, tracer } = _makeMetadataHarness();
 
-  const wrap = weflayr.propagateMetadata({ featureName: 'f', customerId: 'c' });
+  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');
@@ -515,7 +515,7 @@ test('propagateMetadata decorator form wraps a function', async () => {
 
   const wrap = weflayr.propagateMetadata({
     featureName: 'chat',
-    customerId: 'c_42',
+    customerName: 'c_42',
     extraTags: { experiment: 'B' },
   });
   const leaf = wrap(async function leaf() {
@@ -528,7 +528,7 @@ test('propagateMetadata decorator form wraps a function', async () => {
   await proc.forceFlush();
   const attrs = exporter.exported[0].attributes;
   assert.equal(attrs['weflayr.feature_name'], 'chat');
-  assert.equal(attrs['weflayr.customer_id'], 'c_42');
+  assert.equal(attrs['weflayr.customer_name'], 'c_42');
   assert.equal(attrs['weflayr.tag.experiment'], 'B');
   await provider.shutdown();
 });
@@ -539,7 +539,7 @@ test('propagateMetadata callable form runs function', async () => {
   const result = await weflayr.propagateMetadata(
     {
       featureName: 'callable',
-      customerId: 'c_42',
+      customerName: 'c_42',
       extraTags: { variant: 'A' },
     },
     async () => {
@@ -564,7 +564,7 @@ test('propagateMetadata providerName writes attribute', async () => {
   await weflayr.propagateMetadata(
     {
       featureName: 'f',
-      customerId: 'c',
+      customerName: 'c',
       providerName: weflayr.AIProviderName.VERCEL_AI_GATEWAY,
     },
     async () => {
@@ -579,10 +579,34 @@ test('propagateMetadata providerName writes attribute', async () => {
   await provider.shutdown();
 });
 
-test('propagateMetadata requires featureName and customerId', () => {
-  assert.throws(() => weflayr.propagateMetadata({}), /featureName.*customerId.*required/);
+test('propagateMetadata requires featureName and customerName', () => {
+  assert.throws(() => weflayr.propagateMetadata({}), /featureName.*customerName.*required/);
   assert.throws(() => weflayr.propagateMetadata({ featureName: 'f' }), /required/);
-  assert.throws(() => weflayr.propagateMetadata({ customerId: 'c' }), /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 ────────────────────────────────────────────────────────────
@@ -688,6 +712,15 @@ test('autoInstrument throws when no apiKey is reachable (env nor argument)', asy
   }
 });
 
+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 {

package/tests/instrumentation/vercel/full_instrumentation.test.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  VercelAiSdkInstrumentor,
+} = require('../../../src/instrumentation/vercel/full_instrumentation');
+
+// The `ai` / `@ai-sdk/otel` packages are app dependencies (not installed in
+// this repo), so instrument() must fail with an actionable install message.
+// The success path (registerTelemetry wiring) is covered by the vercel e2e
+// ingestion scenario.
+test('instrument() without the ai packages installed throws an install hint', () => {
+  assert.throws(() => new VercelAiSdkInstrumentor().instrument(), /npm install ai @ai-sdk\/otel/);
+});

package/tests/otel/vercel-ai-sdk-span-filter.test.js

@@ -0,0 +1,159 @@
+'use strict';
+
+// The Vercel AI SDK emits aggregate spans around each model call (see
+// src/otel/vercel-ai-sdk-span-filter.js). These tests drive real spans through
+// the WeflayrSpanProcessor and assert exactly one span per model call is
+// exported, for both the ai >= 7 semconv shape and the legacy ai.* shape.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { context, trace } = require('@opentelemetry/api');
+const { BasicTracerProvider, InMemorySpanExporter } = require('@opentelemetry/sdk-trace-base');
+
+const { WeflayrSpanProcessor } = require('../../src/otel/span-processor');
+
+function buildProviderWithExporter() {
+  const exporter = new InMemorySpanExporter();
+  const provider = new BasicTracerProvider({
+    spanProcessors: [new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' })],
+  });
+  return { exporter, provider };
+}
+
+function startChildSpan(tracer, parentSpan, name, attributes) {
+  const parentContext = trace.setSpan(context.active(), parentSpan);
+  return tracer.startSpan(name, { attributes }, parentContext);
+}
+
+test('semconv shape: only the chat span is exported, not invoke_agent/step/tool', () => {
+  const { exporter, provider } = buildProviderWithExporter();
+  const tracer = provider.getTracer('gen_ai');
+
+  const invokeAgent = tracer.startSpan('invoke_agent openai/gpt-4o-mini', {
+    attributes: {
+      'gen_ai.operation.name': 'invoke_agent',
+      'gen_ai.usage.input_tokens': 50,
+      'gen_ai.usage.output_tokens': 15,
+    },
+  });
+  const step = startChildSpan(tracer, invokeAgent, 'step 1', {
+    'gen_ai.operation.name': 'agent_step',
+  });
+  const chat = startChildSpan(tracer, step, 'chat openai/gpt-4o-mini', {
+    'gen_ai.operation.name': 'chat',
+    'gen_ai.usage.input_tokens': 50,
+    'gen_ai.usage.output_tokens': 15,
+  });
+  const tool = startChildSpan(tracer, step, 'execute_tool get_weather', {
+    'gen_ai.operation.name': 'execute_tool',
+  });
+
+  chat.end();
+  tool.end();
+  step.end();
+  invokeAgent.end();
+
+  const exported = exporter.getFinishedSpans();
+  assert.equal(exported.length, 1);
+  assert.equal(exported[0].name, 'chat openai/gpt-4o-mini');
+});
+
+test('semconv shape: nested embeddings span is dropped, the outer one is exported', () => {
+  const { exporter, provider } = buildProviderWithExporter();
+  const tracer = provider.getTracer('gen_ai');
+
+  const outerEmbeddings = tracer.startSpan('embeddings openai/text-embedding-3-small', {
+    attributes: {
+      'gen_ai.operation.name': 'embeddings',
+      'gen_ai.usage.input_tokens': 2,
+    },
+  });
+  const modelCallEmbeddings = startChildSpan(
+    tracer,
+    outerEmbeddings,
+    'embeddings openai/text-embedding-3-small',
+    {
+      'gen_ai.operation.name': 'embeddings',
+      'gen_ai.usage.input_tokens': 2,
+    }
+  );
+
+  modelCallEmbeddings.end();
+  outerEmbeddings.end();
+
+  const exported = exporter.getFinishedSpans();
+  assert.equal(exported.length, 1);
+  assert.equal(exported[0].spanContext().spanId, outerEmbeddings.spanContext().spanId);
+});
+
+test('legacy shape: only ai.<fn>.do* spans are exported', () => {
+  const { exporter, provider } = buildProviderWithExporter();
+  const tracer = provider.getTracer('ai');
+
+  const outer = tracer.startSpan('ai.streamText', {
+    attributes: { 'ai.usage.inputTokens': 100 },
+  });
+  const doStream = startChildSpan(tracer, outer, 'ai.streamText.doStream', {
+    'gen_ai.usage.input_tokens': 100,
+  });
+  const toolCall = startChildSpan(tracer, outer, 'ai.toolCall', {});
+  const doEmbed = tracer.startSpan('ai.embed.doEmbed', {
+    attributes: { 'gen_ai.usage.input_tokens': 1 },
+  });
+
+  doStream.end();
+  toolCall.end();
+  doEmbed.end();
+  outer.end();
+
+  const exported = exporter.getFinishedSpans().map((span) => span.name);
+  assert.deepEqual(exported.sort(), ['ai.embed.doEmbed', 'ai.streamText.doStream']);
+});
+
+test('gateway provider id gets the weflayr override, direct providers do not', () => {
+  const { exporter, provider } = buildProviderWithExporter();
+  const tracer = provider.getTracer('gen_ai');
+
+  const gatewayChat = tracer.startSpan('chat openai/gpt-4o-mini', {
+    attributes: { 'gen_ai.operation.name': 'chat', 'gen_ai.provider.name': 'gateway' },
+  });
+  gatewayChat.end();
+  const directChat = tracer.startSpan('chat gpt-4o-mini', {
+    attributes: { 'gen_ai.operation.name': 'chat', 'gen_ai.provider.name': 'openai' },
+  });
+  directChat.end();
+
+  const [gatewayExported, directExported] = exporter.getFinishedSpans();
+  assert.equal(gatewayExported.attributes['weflayr.provider_name'], 'vercel_ai_gateway');
+  assert.equal(directExported.attributes['weflayr.provider_name'], undefined);
+});
+
+test('gateway provider id does not overwrite a propagateMetadata providerName', () => {
+  const { exporter, provider } = buildProviderWithExporter();
+  const tracer = provider.getTracer('gen_ai');
+
+  const chat = tracer.startSpan('chat openai/gpt-4o-mini', {
+    attributes: {
+      'gen_ai.operation.name': 'chat',
+      'gen_ai.provider.name': 'gateway',
+      'weflayr.provider_name': 'openai',
+    },
+  });
+  chat.end();
+
+  assert.equal(exporter.getFinishedSpans()[0].attributes['weflayr.provider_name'], 'openai');
+});
+
+test('non-Vercel scopes still go through the default export filter', () => {
+  const { exporter, provider } = buildProviderWithExporter();
+
+  const llmSpan = provider
+    .getTracer('@traceloop/instrumentation-openai')
+    .startSpan('openai.chat', { attributes: { 'gen_ai.system': 'openai' } });
+  llmSpan.end();
+  const unrelatedSpan = provider.getTracer('my-app').startSpan('http request');
+  unrelatedSpan.end();
+
+  const exported = exporter.getFinishedSpans().map((span) => span.name);
+  assert.deepEqual(exported, ['openai.chat']);
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  // First TypeScript module of the SDK: only src/api is compiled (to dist/);
+  // the rest of src stays plain JavaScript until it is migrated.
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/api"]
+}