weflayr 0.16.1 → 0.20.2

package/.env.example

@@ -1,3 +0,0 @@
-WEFLAYR_INTAKE_URL=https://api.weflayr.com
-WEFLAYR_CLIENT_ID=your-client-id-uuid
-WEFLAYR_CLIENT_SECRET=your-client-secret

package/src/instrument.js

@@ -1,324 +0,0 @@
-'use strict';
-
-const https = require('https');
-const http = require('http');
-const { randomUUID } = require('crypto');
-const { AsyncLocalStorage } = require('async_hooks');
-const { version: SDK_VERSION } = require('../package.json');
-const SDK_LANGUAGE = 'javascript';
-
-let _config = null;
-const _asyncStore = new AsyncLocalStorage();
-
-function configure(intakeUrl, clientId, clientSecret, settings) {
-  _asyncStore.enterWith({});
-  if (settings.ignore_fields && settings.allow_fields) {
-    console.warn('[weflayr] both ignore_fields and allow_fields are set - no events will be sent to the intake API');
-    _config = { intakeUrl, clientId, clientSecret, settings, _blocked: true };
-    return;
-  }
-  _config = { intakeUrl, clientId, clientSecret, settings, _blocked: false };
-}
-
-function weflayr_instrument(target) {
-  if (!_config) return target;
-
-  if (typeof target === 'function') {
-    const methodConfig = (_config.settings.methods || []).find(m => m.call === target.name);
-    if (!methodConfig) return target;
-    return _wrapFn(target, target.name, methodConfig);
-  }
-
-  if (target && typeof target === 'object') {
-    return _makeProxy(target, '');
-  }
-
-  return target;
-}
-
-function _makeProxy(target, pathPrefix) {
-  return new Proxy(target, {
-    get(obj, prop) {
-      if (typeof prop === 'symbol') return Reflect.get(obj, prop);
-
-      const value = Reflect.get(obj, prop);
-      const fullPath = pathPrefix ? `${pathPrefix}.${prop}` : prop;
-
-      if (typeof value === 'function') {
-        const methodConfig = (_config.settings.methods || []).find(m => m.call === fullPath);
-        if (methodConfig) {
-          return _wrapFn(value.bind(obj), fullPath, methodConfig);
-        }
-        return value.bind(obj);
-      }
-
-      if (value && typeof value === 'object') {
-        return _makeProxy(value, fullPath);
-      }
-
-      return value;
-    },
-  });
-}
-
-function _wrapFn(fn, methodName, methodConfig) {
-  return async function (...args) {
-    const { tags, cleanArgs } = _extractTags(args);
-    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(requestArgs, null) || {}
-        : {};
-      _sendEvent('before', {
-        event_id: eventId,
-        method: methodName,
-        tags,
-        args: _applyContentPolicy(requestArgs, settings),
-        ...beforeMiddlewareData,
-      });
-    }
-
-    try {
-      const result = await fn(...cleanArgs);
-
-      if (_isAsyncIterable(result)) {
-        _sendEvent('stream_start', { event_id: eventId, method: methodName, tags });
-        return _wrapStream(result, methodName, tags, requestArgs, settings, startTime, methodConfig, eventId);
-      }
-
-      if (methodConfig.streamPath && result && _isAsyncIterable(result[methodConfig.streamPath])) {
-        _sendEvent('stream_start', { event_id: eventId, method: methodName, tags });
-        const wrappedStream = _wrapStream(result[methodConfig.streamPath], methodName, tags, requestArgs, settings, startTime, methodConfig, eventId, result);
-        return { ...result, [methodConfig.streamPath]: wrappedStream };
-      }
-
-      const middlewareData = methodConfig.middleware
-        ? methodConfig.middleware(requestArgs, result) || {}
-        : {};
-
-      _sendEvent('after', {
-        event_id: eventId,
-        method: methodName,
-        tags,
-        args: _applyContentPolicy(requestArgs, settings),
-        response: _applyContentPolicy(_toPlain(result), settings),
-        elapsed_ms: Date.now() - startTime,
-        ...middlewareData,
-      });
-
-      return result;
-    } catch (err) {
-      await _sendEvent('after', {
-        event_id: eventId,
-        method: methodName,
-        tags,
-        args: _applyContentPolicy(requestArgs, settings),
-        error: err.message ?? 'unknown',
-        status_code: err.status ?? err.statusCode ?? 'unknown',
-        elapsed_ms: Date.now() - startTime,
-      });
-      throw err;
-    }
-  };
-}
-
-// fullResult is only set for the streamPath case — it's the full SDK result object
-// (e.g. Mastra's StreamTextResult) so streamMiddleware factories can close over it
-// and await properties like result.usage after the stream drains.
-async function* _wrapStream(stream, methodName, tags, requestArgs, settings, startTime, methodConfig, eventId, fullResult) {
-  let lastChunk = null;
-  const accumulator = methodConfig.streamMiddleware ? methodConfig.streamMiddleware(fullResult) : 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,
-          ...(await accumulator.finalize()),
-        });
-      }
-      yield chunk;
-    }
-
-    const rawMiddlewareData = accumulator
-      ? (await accumulator.finalize()) || {}
-      : (methodConfig.middleware && lastChunk ? methodConfig.middleware(requestArgs, lastChunk) || {}
-      : {});
-    const middlewareData = _applyContentPolicy(rawMiddlewareData, settings);
-
-    _sendEvent('after', {
-      event_id: eventId,
-      method: methodName,
-      tags,
-      args: _applyContentPolicy(requestArgs, settings),
-      response: _applyContentPolicy(_toPlain(lastChunk), settings),
-      elapsed_ms: Date.now() - startTime,
-      ...middlewareData,
-    });
-  } catch (err) {
-    await _sendEvent('after', {
-      event_id: eventId,
-      method: methodName,
-      tags,
-      args: _applyContentPolicy(requestArgs, settings),
-      error: err.message ?? 'unknown',
-      status_code: err.status ?? err.statusCode ?? 'unknown',
-      elapsed_ms: Date.now() - startTime,
-    });
-    throw err;
-  }
-}
-
-function _extractTags(args) {
-  let callTags = {};
-
-  function strip(obj) {
-    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return;
-    if ('__weflayr_tags' in obj) {
-      callTags = obj.__weflayr_tags || {};
-      delete obj.__weflayr_tags;
-    }
-    for (const key of Object.keys(obj)) {
-      strip(obj[key]);
-    }
-  }
-
-  const cleanArgs = args.map(arg => {
-    if (arg && typeof arg === 'object' && !Array.isArray(arg)) strip(arg);
-    return arg;
-  });
-
-  const tags = {
-    ...(_config.settings.default_tags || {}),
-    ..._asyncStore.getStore(),
-    ...callTags,
-  };
-
-  return { tags, cleanArgs };
-}
-
-function weflayr_propagate(key, value) {
-  _asyncStore.getStore()[key] = value;
-}
-
-
-function _isAsyncIterable(value) {
-  return value != null && typeof value[Symbol.asyncIterator] === 'function';
-}
-
-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;
-}
-
-function _applyContentPolicy(data, settings) {
-  if (!data) return data;
-  const fn = settings.ignore_fields || settings.allow_fields;
-  if (!fn) return data;
-  let clone;
-  try {
-    clone = JSON.parse(JSON.stringify(data));
-  } catch {
-    return data;
-  }
-  try {
-    return fn(clone) ?? clone;
-  } catch (err) {
-    console.warn('[weflayr] content policy function error:', err.message);
-    return clone;
-  }
-}
-
-const _debug = process.env.WEFLAYR_DEBUG === 'true';
-
-function _sendEvent(eventType, data) {
-  if (_config._blocked) {
-    console.warn(`[weflayr] is blocked and can't send event, ensure your configuration is valid`);
-    return;
-  }
-  const { intakeUrl, clientId, clientSecret } = _config;
-  const endpoint = `${intakeUrl.replace(/\/$/, '')}/${clientId}/`;
-
-  let body;
-  try {
-    body = JSON.stringify({
-      event_type: eventType,
-      timestamp: new Date().toISOString(),
-      sdk_version: SDK_VERSION,
-      sdk_language: SDK_LANGUAGE,
-      ...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 {
-    parsed = new URL(endpoint);
-  } catch {
-    return;
-  }
-
-  const lib = parsed.protocol === 'https:' ? https : http;
-  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);
-      resolve();
-    });
-
-    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);
-}
-
-// Returns merged default_tags + propagated async-local tags. Used by the Vercel AI middleware.
-function get_context_tags() {
-  if (!_config) return {};
-  return { ...(_config.settings.default_tags || {}), ..._asyncStore.getStore() };
-}
-
-module.exports = { configure, weflayr_instrument, weflayr_propagate, send_event, get_context_tags };

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

@@ -1,63 +0,0 @@
-'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/src/providers/bedrock-runtime.d.ts

@@ -1,6 +0,0 @@
-import { MethodConfig, StreamAccumulator } from '../../../index';
-
-export function createStreamAccumulator(): StreamAccumulator;
-
-/** Ready-to-use method config for `client.send(new ConverseStreamCommand(...))`. */
-export const converseStream: MethodConfig;

package/src/providers/bedrock-runtime.js

@@ -1,28 +0,0 @@
-'use strict';
-
-function createStreamAccumulator() {
-  let input_tokens = null;
-  let output_tokens = null;
-
-  return {
-    onChunk(chunk) {
-      if (chunk.metadata?.usage) {
-        input_tokens = chunk.metadata.usage.inputTokens ?? null;
-        output_tokens = chunk.metadata.usage.outputTokens ?? null;
-        return true;
-      }
-      return false;
-    },
-    finalize() {
-      return { input_tokens, output_tokens };
-    },
-  };
-}
-
-const converseStream = {
-  call: 'send',
-  streamPath: 'stream',
-  streamMiddleware: createStreamAccumulator,
-};
-
-module.exports = { converseStream, createStreamAccumulator };

package/src/vercel-ai-middleware.js

@@ -1,124 +0,0 @@
-'use strict';
-
-const { randomUUID } = require('crypto');
-const { send_event, get_context_tags } = require('./instrument');
-
-/**
- * Returns a Vercel AI SDK LanguageModelV1Middleware that emits Weflayr events.
- * Requires weflayr_setup() to have been called first.
- *
- * @param {{ tags?: Record<string, string | number | boolean> }} [options]
- * @returns {object} Vercel AI SDK middleware
- */
-function weflayr_vercel_ai_middleware(options) {
-  const callTags = options?.tags ?? {};
-  const modelId = options?.model ?? 'unknown';
-
-  return {
-    wrapGenerate: async ({ doGenerate }) => {
-      const eventId = randomUUID();
-      const t0 = Date.now();
-      const tags = { ...get_context_tags(), ...callTags };
-
-      send_event('before', {
-        event_id: eventId,
-        method: 'vercel.generate',
-        tags,
-        args: { model: modelId },
-      });
-
-      try {
-        const result = await doGenerate();
-        send_event('after', {
-          event_id: eventId,
-          method: 'vercel.generate',
-          tags,
-          args: { model: modelId },
-          response: { usage: result.usage, finish_reason: result.finishReason },
-          elapsed_ms: Date.now() - t0,
-        });
-        return result;
-      } catch (err) {
-        send_event('after', {
-          event_id: eventId,
-          method: 'vercel.generate',
-          tags,
-          args: { model: modelId },
-          error: err.message ?? 'unknown',
-          elapsed_ms: Date.now() - t0,
-        });
-        throw err;
-      }
-    },
-
-    wrapStream: async ({ doStream }) => {
-      const eventId = randomUUID();
-      const t0 = Date.now();
-      const tags = { ...get_context_tags(), ...callTags };
-
-      send_event('before', {
-        event_id: eventId,
-        method: 'vercel.stream',
-        tags,
-        args: { model: modelId },
-      });
-
-      try {
-        const { stream, ...rest } = await doStream();
-
-        send_event('stream_start', {
-          event_id: eventId,
-          method: 'vercel.stream',
-          tags,
-        });
-
-        let finishChunk = null;
-        let errorChunk = null;
-        const patched = new TransformStream({
-          transform(chunk, controller) {
-            if (chunk.type === 'finish') finishChunk = chunk;
-            if (chunk.type === 'error') errorChunk = chunk;
-            controller.enqueue(chunk);
-          },
-          flush() {
-            if (errorChunk) {
-              send_event('after', {
-                event_id: eventId,
-                method: 'vercel.stream',
-                tags,
-                args: { model: modelId },
-                error: String(errorChunk.error),
-                elapsed_ms: Date.now() - t0,
-              });
-            } else {
-              send_event('after', {
-                event_id: eventId,
-                method: 'vercel.stream',
-                tags,
-                args: { model: modelId },
-                response: finishChunk
-                  ? { usage: finishChunk.usage, finish_reason: finishChunk.finishReason }
-                  : null,
-                elapsed_ms: Date.now() - t0,
-              });
-            }
-          },
-        });
-
-        return { stream: stream.pipeThrough(patched), ...rest };
-      } catch (err) {
-        send_event('after', {
-          event_id: eventId,
-          method: 'vercel.stream',
-          tags,
-          args: { model: modelId },
-          error: err.message ?? 'unknown',
-          elapsed_ms: Date.now() - t0,
-        });
-        throw err;
-      }
-    },
-  };
-}
-
-module.exports = { weflayr_vercel_ai_middleware };