weflayr 0.2.0 → 0.3.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "weflayr",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Weflayr Node.js SDK — instrument any LLM client via JS Proxy",
   "main": "src/index.js",
   "scripts": {
-    "test": "node --test tests/"
+    "test": "node --test tests/index.test.js"
   },
   "keywords": ["llm", "observability", "weflayr"],
   "author": "Weflayr <contact@weflayr.com>",

package/src/index.js

@@ -2,7 +2,7 @@
 
 require('dotenv').config();
 
-const { configure, weflayr_instrument } = require('./instrument');
+const { configure, weflayr_instrument, send_event } = require('./instrument');
 
 /**
  * 
@@ -26,4 +26,4 @@ function weflayr_setup(settings, { enabled = true } = {}) {
   configure(intakeUrl, clientId, clientSecret, settings);
 }
 
-module.exports = { weflayr_setup, weflayr_instrument };
+module.exports = { weflayr_setup, weflayr_instrument, send_event };

package/src/instrument.js

@@ -14,7 +14,7 @@ function weflayr_instrument(target) {
   if (!_config) return target;
 
   if (typeof target === 'function') {
-    const methodConfig = _config.settings.methods.find(m => m.call === target.name);
+    const methodConfig = (_config.settings.methods || []).find(m => m.call === target.name);
     if (!methodConfig) return target;
     return _wrapFn(target, target.name, methodConfig);
   }
@@ -35,7 +35,7 @@ function _makeProxy(target, pathPrefix) {
       const fullPath = pathPrefix ? `${pathPrefix}.${prop}` : prop;
 
       if (typeof value === 'function') {
-        const methodConfig = _config.settings.methods.find(m => m.call === fullPath);
+        const methodConfig = (_config.settings.methods || []).find(m => m.call === fullPath);
         if (methodConfig) {
           return _wrapFn(value.bind(obj), fullPath, methodConfig);
         }
@@ -57,16 +57,19 @@ function _wrapFn(fn, methodName, methodConfig) {
     const startTime = Date.now();
     const { settings } = _config;
     const eventId = randomUUID();
+    // For multi-arg methods (e.g. convert(voiceId, request)), use the last arg as the
+    // request object so middleware and content policy see the options, not the id.
+    const requestArgs = cleanArgs[cleanArgs.length - 1];
 
     if (settings.event_mode !== 'light') {
       const beforeMiddlewareData = methodConfig.middleware
-        ? methodConfig.middleware(cleanArgs[0], null) || {}
+        ? methodConfig.middleware(requestArgs, null) || {}
         : {};
       _sendEvent('before', {
         event_id: eventId,
         method: methodName,
         tags,
-        args: _applyContentPolicy(cleanArgs[0], settings),
+        args: _applyContentPolicy(requestArgs, settings),
         ...beforeMiddlewareData,
       });
     }
@@ -76,18 +79,18 @@ function _wrapFn(fn, methodName, methodConfig) {
 
       if (_isAsyncIterable(result)) {
         _sendEvent('stream_start', { event_id: eventId, method: methodName, tags });
-        return _wrapStream(result, methodName, tags, cleanArgs[0], settings, startTime, methodConfig, eventId);
+        return _wrapStream(result, methodName, tags, requestArgs, settings, startTime, methodConfig, eventId);
       }
 
       const middlewareData = methodConfig.middleware
-        ? methodConfig.middleware(cleanArgs[0], result) || {}
+        ? methodConfig.middleware(requestArgs, result) || {}
         : {};
 
       _sendEvent('after', {
         event_id: eventId,
         method: methodName,
         tags,
-        args: _applyContentPolicy(cleanArgs[0], settings),
+        args: _applyContentPolicy(requestArgs, settings),
         response: _applyContentPolicy(_toPlain(result), settings),
         elapsed_ms: Date.now() - startTime,
         ...middlewareData,
@@ -95,13 +98,13 @@ function _wrapFn(fn, methodName, methodConfig) {
 
       return result;
     } catch (err) {
-      _sendEvent('after', {
+      await _sendEvent('after', {
         event_id: eventId,
         method: methodName,
         tags,
-        args: _applyContentPolicy(cleanArgs[0], settings),
-        error: err.message,
-        status_code: err.status,
+        args: _applyContentPolicy(requestArgs, settings),
+        error: err.message ?? 'unknown',
+        status_code: err.status ?? err.statusCode ?? 'unknown',
         elapsed_ms: Date.now() - startTime,
       });
       throw err;
@@ -111,16 +114,27 @@ function _wrapFn(fn, methodName, methodConfig) {
 
 async function* _wrapStream(stream, methodName, tags, requestArgs, settings, startTime, methodConfig, eventId) {
   let lastChunk = null;
+  const accumulator = methodConfig.streamMiddleware ? methodConfig.streamMiddleware() : null;
 
   try {
     for await (const chunk of stream) {
       lastChunk = chunk;
+      if (accumulator && accumulator.onChunk(chunk)) {
+        _sendEvent('stream_pending', {
+          event_id: eventId,
+          method: methodName,
+          tags,
+          elapsed_ms: Date.now() - startTime,
+          ...accumulator.finalize(),
+        });
+      }
       yield chunk;
     }
 
-    const middlewareData = methodConfig.middleware && lastChunk
-      ? methodConfig.middleware(requestArgs, lastChunk) || {}
-      : {};
+    const middlewareData = accumulator
+      ? accumulator.finalize()
+      : (methodConfig.middleware && lastChunk ? methodConfig.middleware(requestArgs, lastChunk) || {}
+      : {});
 
     _sendEvent('after', {
       event_id: eventId,
@@ -132,12 +146,13 @@ async function* _wrapStream(stream, methodName, tags, requestArgs, settings, sta
       ...middlewareData,
     });
   } catch (err) {
-    _sendEvent('after', {
+    await _sendEvent('after', {
       event_id: eventId,
       method: methodName,
       tags,
       args: _applyContentPolicy(requestArgs, settings),
-      error: err.message,
+      error: err.message ?? 'unknown',
+      status_code: err.status ?? err.statusCode ?? 'unknown',
       elapsed_ms: Date.now() - startTime,
     });
     throw err;
@@ -163,6 +178,7 @@ function _isAsyncIterable(value) {
 
 function _toPlain(value) {
   if (!value) return value;
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array || value instanceof ArrayBuffer) return null;
   if (typeof value.toJSON === 'function') return value.toJSON();
   return value;
 }
@@ -177,15 +193,14 @@ function _applyContentPolicy(data, settings) {
     return data;
   }
 
-  if (settings.content_policy === 'allow') {
-    return _pickFields(clone, settings.allow_fields || []);
-  }
-
-  for (const field of (settings.ignore_fields || [])) {
-    _deleteField(clone, field);
+  if (settings.content_policy === 'ignore') {
+    for (const field of (settings.ignore_fields || [])) {
+      _deleteField(clone, field);
+    }
+    return clone;
   }
 
-  return clone;
+  return _pickFields(clone, settings.allow_fields || []);
 }
 
 function _pickFields(obj, allowFields) {
@@ -234,15 +249,27 @@ function _deleteField(obj, path) {
   }
 }
 
+const _debug = process.env.WEFLAYR_DEBUG === 'true';
+
 function _sendEvent(eventType, data) {
   const { intakeUrl, clientId, clientSecret } = _config;
   const endpoint = `${intakeUrl.replace(/\/$/, '')}/${clientId}/`;
 
-  const body = JSON.stringify({
-    event_type: eventType,
-    timestamp: new Date().toISOString(),
-    ...data,
-  });
+  let body;
+  try {
+    body = JSON.stringify({
+      event_type: eventType,
+      timestamp: new Date().toISOString(),
+      ...data,
+    });
+  } catch (err) {
+    console.warn(`[weflayr] could not serialize event "${eventType}":`, err.message);
+    return;
+  }
+
+  if (_debug) {
+    console.debug(`[weflayr] → ${eventType}`, JSON.parse(body));
+  }
 
   let parsed;
   try {
@@ -252,30 +279,42 @@ function _sendEvent(eventType, data) {
   }
 
   const lib = parsed.protocol === 'https:' ? https : http;
-  const req = lib.request({
-    hostname: parsed.hostname,
-    port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
-    path: parsed.pathname,
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Content-Length': Buffer.byteLength(body),
-      'Authorization': `Bearer ${clientSecret}`,
-    },
-  }, res => {
-    res.resume();
-    if (res.statusCode >= 400) {
-      console.warn(`[weflayr] intake returned ${res.statusCode} for event "${eventType}"`);
-    }
-  });
+  return new Promise((resolve) => {
+    const req = lib.request({
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        'Authorization': `Bearer ${clientSecret}`,
+      },
+    }, res => {
+      res.resume();
+      if (_debug) {
+        console.debug(`[weflayr] ← ${eventType} status ${res.statusCode}`);
+      }
+      if (res.statusCode >= 400) {
+        console.warn(`[weflayr] intake returned ${res.statusCode} for event "${eventType}"`);
+      }
+      resolve();
+    });
 
-  req.on('error', (err) => {
-    console.warn(`[weflayr] send error for event "${eventType}":`, err.message);
+    req.on('error', (err) => {
+      console.warn(`[weflayr] send error for event "${eventType}":`, err.message);
+      resolve();
+    });
+
+    req.write(body);
+    req.end();
   });
+}
 
-  req.write(body);
-  
-  req.end();
+// Send an arbitrary event to the intake. Requires configure() to have been called first.
+function send_event(eventType, data) {
+  if (!_config) return;
+  return _sendEvent(eventType, data);
 }
 
-module.exports = { configure, weflayr_instrument };
+module.exports = { configure, weflayr_instrument, send_event };

package/src/providers/anthropic-ai-sdk.js

@@ -0,0 +1,63 @@
+'use strict';
+
+// Non-streaming: extract usage from the completed message response.
+function middleware(request, response) {
+  if (!response) return { model: request?.model ?? null };
+  return {
+    model: response.model ?? request?.model ?? null,
+    input_tokens: response.usage?.input_tokens ?? null,
+    output_tokens: response.usage?.output_tokens ?? null,
+    cache_creation_input_tokens: response.usage?.cache_creation_input_tokens ?? null,
+    cache_read_input_tokens: response.usage?.cache_read_input_tokens ?? null,
+  };
+}
+
+// Streaming: Anthropic splits usage across two events.
+//   message_start  → usage.input_tokens  (prompt cost)
+//   message_delta  → usage.output_tokens (completion cost, cumulative final value)
+//   message_stop   → no usage data
+// onChunk returns true only when usage state changes, so _wrapStream fires
+// stream_pending exactly twice: once after message_start, once after message_delta.
+function createStreamAccumulator() {
+  let input_tokens = null;
+  let output_tokens = null;
+  let cache_creation_input_tokens = null;
+  let cache_read_input_tokens = null;
+  let model = null;
+
+  return {
+    onChunk(chunk) {
+      if (chunk.type === 'message_start') {
+        const usage = chunk.message?.usage;
+        model = chunk.message?.model ?? null;
+        input_tokens = usage?.input_tokens ?? null;
+        cache_creation_input_tokens = usage?.cache_creation_input_tokens ?? null;
+        cache_read_input_tokens = usage?.cache_read_input_tokens ?? null;
+        return true;
+      }
+      if (chunk.type === 'message_delta') {
+        output_tokens = chunk.usage?.output_tokens ?? null;
+        return true;
+      }
+      return false;
+    },
+    finalize() {
+      return {
+        model,
+        input_tokens,
+        output_tokens,
+        cache_creation_input_tokens,
+        cache_read_input_tokens,
+      };
+    },
+  };
+}
+
+// Ready-to-use method config for client.messages.create.
+const messagesCreate = {
+  call: 'messages.create',
+  middleware: middleware,
+  streamMiddleware: createStreamAccumulator,
+};
+
+module.exports = { messagesCreate, middleware, createStreamAccumulator };

package/tests/index.test.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('assert/strict');
+
+// Reset module cache between tests so _config doesn't leak
+function freshSDK() {
+  delete require.cache[require.resolve('../src/instrument')];
+  delete require.cache[require.resolve('../src/index')];
+  process.env.WEFLAYR_INTAKE_URL = 'http://localhost:19999'; // nothing listening — fire-and-forget is fine
+  process.env.WEFLAYR_CLIENT_ID = 'test-client-id';
+  process.env.WEFLAYR_CLIENT_SECRET = 'test-secret';
+  return require('../src/index');
+}
+
+// Minimal fake client: one async method at a nested path
+function fakeClient() {
+  return {
+    chat: {
+      completions: {
+        create: async (args) => ({ id: 'res-1', model: args.model, choices: [] }),
+      },
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Missing options don't crash
+// ---------------------------------------------------------------------------
+
+test('missing ignore_fields does not crash', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  weflayr_setup({
+    event_mode: 'default',
+    content_policy: 'ignore',
+    // ignore_fields intentionally omitted
+    methods: [{ call: 'chat.completions.create' }],
+  });
+
+  const client = weflayr_instrument(fakeClient());
+  const result = await client.chat.completions.create({ model: 'gpt-4o-mini', messages: [] });
+
+  assert.equal(result.id, 'res-1');
+});
+
+test('missing allow_fields does not crash', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  weflayr_setup({
+    event_mode: 'default',
+    content_policy: 'allow',
+    // allow_fields intentionally omitted
+    methods: [{ call: 'chat.completions.create' }],
+  });
+
+  const client = weflayr_instrument(fakeClient());
+  const result = await client.chat.completions.create({ model: 'gpt-4o-mini', messages: [] });
+
+  assert.equal(result.id, 'res-1');
+});
+
+test('missing methods does not crash on object instrumentation', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  weflayr_setup({
+    event_mode: 'default',
+    content_policy: 'ignore',
+    // methods intentionally omitted
+  });
+
+  const client = weflayr_instrument(fakeClient());
+  const result = await client.chat.completions.create({ model: 'gpt-4o-mini', messages: [] });
+
+  assert.equal(result.id, 'res-1');
+});
+
+test('missing methods does not crash on function instrumentation', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  weflayr_setup({
+    event_mode: 'default',
+    content_policy: 'ignore',
+    // methods intentionally omitted
+  });
+
+  async function myFn(x) { return x * 2; }
+  const instrumented = weflayr_instrument(myFn);
+
+  assert.equal(await instrumented(5), 10);
+});
+
+// ---------------------------------------------------------------------------
+// enabled: false — target passes through unchanged, calls still work
+// ---------------------------------------------------------------------------
+
+test('enabled:false returns the original object untouched', () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  weflayr_setup({ methods: [{ call: 'chat.completions.create' }] }, { enabled: false });
+
+  const client = fakeClient();
+  const result = weflayr_instrument(client);
+
+  assert.strictEqual(result, client);
+});
+
+test('enabled:false returns the original function untouched', () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  async function myFn(x) { return x * 2; }
+  weflayr_setup({ methods: [{ call: 'myFn' }] }, { enabled: false });
+
+  assert.strictEqual(weflayr_instrument(myFn), myFn);
+});
+
+test('enabled:false — original function still executes correctly', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  weflayr_setup({ methods: [{ call: 'chat.completions.create' }] }, { enabled: false });
+
+  const client = weflayr_instrument(fakeClient());
+  const result = await client.chat.completions.create({ model: 'gpt-4o-mini', messages: [] });
+
+  assert.equal(result.id, 'res-1');
+});
+
+// ---------------------------------------------------------------------------
+// Invalid content_policy falls back to allow — function still works correctly
+// ---------------------------------------------------------------------------
+
+test('invalid content_policy does not crash', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  weflayr_setup({
+    event_mode: 'default',
+    content_policy: 'not_a_real_policy',
+    allow_fields: [],
+    methods: [{ call: 'chat.completions.create' }],
+  });
+
+  const client = weflayr_instrument(fakeClient());
+  const result = await client.chat.completions.create({ model: 'gpt-4o-mini', messages: [] });
+
+  assert.equal(result.id, 'res-1');
+});
+
+test('invalid content_policy does not apply ignore_fields', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  let capturedArgs;
+  const client = {
+    chat: {
+      completions: {
+        create: async (args) => { capturedArgs = args; return { id: 'res-1' }; },
+      },
+    },
+  };
+
+  weflayr_setup({
+    event_mode: 'default',
+    content_policy: 'not_a_real_policy',
+    ignore_fields: ['messages'],
+    allow_fields: [],
+    methods: [{ call: 'chat.completions.create' }],
+  });
+
+  const instrumented = weflayr_instrument(client);
+  await instrumented.chat.completions.create({ model: 'gpt-4o-mini', messages: [{ role: 'user', content: 'hello' }] });
+
+  // ignore_fields must NOT have been applied — the real call receives the original args
+  assert.ok(Array.isArray(capturedArgs.messages));
+  assert.equal(capturedArgs.messages[0].content, 'hello');
+});
+
+test('undefined content_policy falls back to allow (pass-through)', async () => {
+  const { weflayr_setup, weflayr_instrument } = freshSDK();
+
+  weflayr_setup({
+    event_mode: 'default',
+    // content_policy intentionally omitted
+    ignore_fields: ['messages'],
+    allow_fields: [],
+    methods: [{ call: 'chat.completions.create' }],
+  });
+
+  const client = weflayr_instrument(fakeClient());
+  const result = await client.chat.completions.create({ model: 'gpt-4o-mini', messages: [] });
+
+  assert.equal(result.id, 'res-1');
+});