weflayr 0.6.2 → 0.7.1

package/package.json

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

package/src/instrument.js

@@ -3,6 +3,8 @@
 const https = require('https');
 const http = require('http');
 const { randomUUID } = require('crypto');
+const { version: SDK_VERSION } = require('../package.json');
+const SDK_LANGUAGE = 'javascript';
 
 let _config = null;
 
@@ -236,6 +238,8 @@ function _sendEvent(eventType, data) {
     body = JSON.stringify({
       event_type: eventType,
       timestamp: new Date().toISOString(),
+      sdk_version: SDK_VERSION,
+      sdk_language: SDK_LANGUAGE,
       ...data,
     });
   } catch (err) {

package/tests/index.test.js

@@ -1,5 +1,38 @@
 'use strict';
 
+// ---------------------------------------------------------------------------
+// Module doubles — registered before any test code so snippet require() calls
+// work without openai installed and without weflayr in node_modules.
+// ---------------------------------------------------------------------------
+{
+  const Module = require('module');
+  const path = require('path');
+  const _origLoad = Module._load;
+  Module._load = function(request, parent, isMain) {
+    if (request === 'openai') {
+      // The real openai package is required as `const OpenAI = require('openai')`,
+      // so the module export IS the constructor (not a namespace object).
+      function OpenAI(_opts) {
+        return {
+          chat: {
+            completions: {
+              create: async (args) => ({ id: 'mock-res', model: args.model || 'gpt-4o-mini', choices: [] }),
+            },
+          },
+          images: {
+            generate: async () => ({ data: [{ b64_json: 'abc123', url: 'https://example.com/img.png' }] }),
+          },
+        };
+      }
+      return OpenAI;
+    }
+    if (request === 'weflayr') {
+      return _origLoad.call(this, path.resolve(__dirname, '../src/index.js'), parent, isMain);
+    }
+    return _origLoad.call(this, request, parent, isMain);
+  };
+}
+
 const { test } = require('node:test');
 const assert = require('assert/strict');
 
@@ -186,3 +219,211 @@ test('enabled:false — original function still executes correctly', async () =>
   assert.equal(result.id, 'res-1');
 });
 
+// ---------------------------------------------------------------------------
+// Documentation snippets
+// All snippet code runs verbatim — Module._load at top of file provides
+// require('openai') and require('weflayr') doubles.
+// update_doc_snippets.py extracts between:  // SNIPPET_START: <name> ... // SNIPPET_END: <name>
+// ---------------------------------------------------------------------------
+
+// Intercept http.request; returns array of parsed event JSON bodies.
+async function captureHttp(fn) {
+  const http = require('http');
+  const sent = [];
+  const origRequest = http.request;
+  http.request = function(_opts, responseCb) {
+    const chunks = [];
+    const req = {
+      write: (d) => chunks.push(typeof d === 'string' ? d : d.toString()),
+      end: () => {
+        try { sent.push(JSON.parse(chunks.join(''))); } catch { /* skip malformed */ }
+        if (responseCb) responseCb({ resume: () => {}, on: () => {}, statusCode: 200 });
+      },
+      on: () => req,
+    };
+    return req;
+  };
+  try { await fn(); } finally { http.request = origRequest; }
+  return sent;
+}
+
+const SNIPPET_ENV = {
+  WEFLAYR_INTAKE_URL: TEST_CREDS.intake_url,
+  WEFLAYR_CLIENT_ID:  TEST_CREDS.client_id,
+  WEFLAYR_CLIENT_SECRET: TEST_CREDS.client_secret,
+  OPENAI_API_KEY: 'sk-test',
+};
+function setSnippetEnv() { Object.assign(process.env, SNIPPET_ENV); }
+
+test('snippet quickstart_setup: wraps client, sends before+after events', async () => {
+  freshSDK();
+  setSnippetEnv();
+
+  const sent = await captureHttp(async () => {
+    // SNIPPET_START: quickstart_setup
+    const OpenAI = require('openai');
+    const { weflayr_setup, weflayr_instrument } = require('weflayr');
+
+    weflayr_setup({
+      intake_url:    process.env.WEFLAYR_INTAKE_URL,
+      client_id:     process.env.WEFLAYR_CLIENT_ID,
+      client_secret: process.env.WEFLAYR_CLIENT_SECRET,
+      methods: [
+        { call: 'chat.completions.create' },
+      ],
+    });
+
+    const client = weflayr_instrument(new OpenAI({ apiKey: process.env.OPENAI_API_KEY }));
+    // SNIPPET_END: quickstart_setup
+
+    assert.equal(typeof client.chat.completions.create, 'function');
+    await client.chat.completions.create({ model: 'gpt-4o-mini', messages: [] });
+  });
+
+  assert.ok(sent.some(e => e.event_type === 'before'), 'before event sent');
+  assert.ok(sent.some(e => e.event_type === 'after'),  'after event sent');
+  assert.equal(sent[0].method, 'chat.completions.create');
+});
+
+test('snippet quickstart_call: tags stripped from call, tags in telemetry', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+  setSnippetEnv();
+
+  let capturedArgs;
+  const raw = {
+    chat: { completions: { create: async (args) => { capturedArgs = args; return { id: 'res-1', choices: [] }; } } },
+  };
+  weflayr_setup({ ...TEST_CREDS, methods: [{ call: 'chat.completions.create' }] });
+  const client = weflayr_instrument(raw);
+
+  const sent = await captureHttp(async () => {
+    // SNIPPET_START: quickstart_call
+    const response = await client.chat.completions.create({
+      model: 'gpt-4o-mini',
+      messages: [{ role: 'user', content: 'Hello!' }],
+      __weflayr_tags: {
+          provider: 'openai',
+          feature: 'onboarding',
+          customer_id: '#3756'
+        },
+    });
+    // response is the standard OpenAI response object — unchanged
+    // SNIPPET_END: quickstart_call
+
+    assert.equal(response.id, 'res-1');
+  });
+
+  assert.ok(!('__weflayr_tags' in capturedArgs), 'tags stripped from underlying call');
+  const before = sent.find(e => e.event_type === 'before');
+  assert.ok(before, 'before event sent');
+  assert.deepEqual(before.tags, { provider: 'openai', feature: 'onboarding', customer_id: '#3756' });
+});
+
+test('snippet openai_full_coverage: 7 methods configured, events sent', async () => {
+  freshSDK();
+  setSnippetEnv();
+
+  const sent = await captureHttp(async () => {
+    // SNIPPET_START: openai_full_coverage
+    const { weflayr_setup, weflayr_instrument } = require('weflayr');
+
+    weflayr_setup({
+      intake_url:    process.env.WEFLAYR_INTAKE_URL,
+      client_id:     process.env.WEFLAYR_CLIENT_ID,
+      client_secret: process.env.WEFLAYR_CLIENT_SECRET,
+      methods: [
+        { call: 'chat.completions.create' },
+        { call: 'completions.create' },
+        { call: 'embeddings.create' },
+        { call: 'responses.create' },
+        {
+          call: 'audio.speech.create',
+          middleware: (args) => ({ char_count: args?.input?.length ?? 0 }),
+        },
+        { call: 'audio.transcriptions.create' },
+        { call: 'audio.translations.create' },
+      ],
+    });
+
+    const OpenAI = require('openai');
+    const client = weflayr_instrument(new OpenAI({ apiKey: process.env.OPENAI_API_KEY }));
+    // SNIPPET_END: openai_full_coverage
+
+    assert.equal(typeof client.chat.completions.create, 'function');
+    await client.chat.completions.create({ model: 'gpt-4o-mini', messages: [] });
+  });
+
+  assert.ok(sent.some(e => e.event_type === 'before'), 'before event sent');
+  assert.ok(sent.some(e => e.event_type === 'after'),  'after event sent');
+  assert.equal(sent[0].method, 'chat.completions.create');
+});
+
+test('snippet openai_tagging: tags stripped from call, all 4 tags in telemetry', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+  setSnippetEnv();
+
+  let capturedArgs;
+  const raw = {
+    chat: { completions: { create: async (args) => { capturedArgs = args; return { id: 'res-1' }; } } },
+  };
+  weflayr_setup({ ...TEST_CREDS, methods: [{ call: 'chat.completions.create' }] });
+  const client = weflayr_instrument(raw);
+
+  const sent = await captureHttp(async () => {
+    // SNIPPET_START: openai_tagging
+    await client.chat.completions.create({
+      model: 'gpt-4o-mini',
+      messages: [{ role: 'user', content: 'Hello' }],
+      __weflayr_tags: {
+        provider: 'openai',
+        feature: 'support-chat',
+        customer_id: 'acme-corp',
+        env: 'production',
+      },
+    });
+    // SNIPPET_END: openai_tagging
+  });
+
+  assert.ok(!('__weflayr_tags' in capturedArgs), 'tags stripped from underlying call');
+  assert.equal(capturedArgs.model, 'gpt-4o-mini');
+  const before = sent.find(e => e.event_type === 'before');
+  assert.ok(before, 'before event sent');
+  assert.deepEqual(before.tags, { provider: 'openai', feature: 'support-chat', customer_id: 'acme-corp', env: 'production' });
+});
+
+test('snippet openai_image_generation: b64_json stripped from telemetry, url preserved', async () => {
+  freshSDK();
+  setSnippetEnv();
+
+  const sent = await captureHttp(async () => {
+    // SNIPPET_START: openai_image_generation
+    const { weflayr_setup, weflayr_instrument } = require('weflayr');
+
+    weflayr_setup({
+      intake_url:    process.env.WEFLAYR_INTAKE_URL,
+      client_id:     process.env.WEFLAYR_CLIENT_ID,
+      client_secret: process.env.WEFLAYR_CLIENT_SECRET,
+      ignore_fields: (data) => {
+        (data.data ?? []).forEach(img => delete img.b64_json);
+        return data;
+      },
+      methods: [
+        { call: 'images.generate' },
+      ],
+    });
+
+    const OpenAI = require('openai');
+    const client = weflayr_instrument(new OpenAI({ apiKey: process.env.OPENAI_API_KEY }));
+    // SNIPPET_END: openai_image_generation
+
+    await client.images.generate({ model: 'gpt-image-1', prompt: 'a cat' });
+  });
+
+  const after = sent.find(e => e.event_type === 'after');
+  assert.ok(after, 'after event sent');
+  for (const img of (after.response?.data ?? [])) {
+    assert.ok(!('b64_json' in img), 'b64_json stripped from telemetry');
+  }
+  assert.ok(after.response.data[0].url, 'url preserved in telemetry');
+});
+