weflayr 0.14.4 → 0.15.1

package/index.d.ts

@@ -99,6 +99,24 @@ export function send_event(
   data: Record<string, unknown>,
 ): Promise<void> | undefined;
 
+/** Options for {@link weflayr_vercel_ai_middleware}. */
+export interface WeflayrVercelAiMiddlewareOptions {
+  /** Static tags attached to every event emitted by this middleware instance. */
+  tags?: Tags;
+}
+
+/**
+ * Returns a Vercel AI SDK `LanguageModelV1Middleware` that emits Weflayr events.
+ * Requires `weflayr_setup` to have been called first.
+ *
+ * @example
+ * const model = wrapLanguageModel({
+ *   model: openai('gpt-4o-mini'),
+ *   middleware: weflayr_vercel_ai_middleware({ tags: { feature: 'chat' } }),
+ * });
+ */
+export function weflayr_vercel_ai_middleware(options?: WeflayrVercelAiMiddlewareOptions): object;
+
 /**
  * Attaches weflayr metadata tags to any SDK call options object.
  *

package/package.json

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

package/src/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { configure, weflayr_instrument, weflayr_propagate, send_event } = require('./instrument');
+const { weflayr_vercel_ai_middleware } = require('./vercel-ai-middleware');
 
 /**
  *
@@ -32,4 +33,4 @@ function flayred(options) {
   return options;
 }
 
-module.exports = { weflayr_setup, weflayr_instrument, weflayr_propagate, send_event, flayred };
+module.exports = { weflayr_setup, weflayr_instrument, weflayr_propagate, send_event, flayred, weflayr_vercel_ai_middleware };

package/src/instrument.js

@@ -315,4 +315,10 @@ function send_event(eventType, data) {
   return _sendEvent(eventType, data);
 }
 
-module.exports = { configure, weflayr_instrument, weflayr_propagate, send_event };
+// 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/vercel-ai-middleware.js

@@ -0,0 +1,124 @@
+'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 };

package/tests/index.test.js

@@ -62,6 +62,72 @@
     if (request === '@ai-sdk/openai') {
       return { openai: (modelId) => ({ _provider: 'openai', modelId }) };
     }
+    if (request === '@ai-sdk/openai-compatible') {
+      function createOpenAICompatible({ name }) {
+        return function(modelId) {
+          return {
+            specificationVersion: 'v1',
+            provider: name,
+            modelId,
+            defaultObjectGenerationMode: undefined,
+            doGenerate: async () => ({
+              text: 'Hello!',
+              usage: { promptTokens: 10, completionTokens: 5 },
+              finishReason: 'stop',
+              rawCall: { rawPrompt: [], rawSettings: {} },
+              rawResponse: { headers: {} },
+              warnings: [],
+            }),
+            doStream: async () => ({
+              stream: new ReadableStream({
+                start(ctrl) {
+                  ctrl.enqueue({ type: 'text-delta', textDelta: 'Hello!' });
+                  ctrl.enqueue({ type: 'finish', finishReason: 'stop', usage: { promptTokens: 10, completionTokens: 5 } });
+                  ctrl.close();
+                },
+              }),
+              rawCall: { rawPrompt: [], rawSettings: {} },
+              rawResponse: { headers: {} },
+              warnings: [],
+            }),
+          };
+        };
+      }
+      return { createOpenAICompatible };
+    }
+    if (request === 'ai') {
+      function wrapLanguageModel({ model, middleware }) {
+        return {
+          modelId: model.modelId,
+          doGenerate: async (params) =>
+            middleware.wrapGenerate({ doGenerate: () => model.doGenerate(params), params, model }),
+          doStream: async (params) =>
+            middleware.wrapStream({ doStream: () => model.doStream(params), params, model }),
+        };
+      }
+      async function generateText({ model, prompt }) {
+        const params = { prompt: [{ role: 'user', content: [{ type: 'text', text: prompt }] }] };
+        return model.doGenerate(params);
+      }
+      function streamText({ model, prompt }) {
+        const params = { prompt: [{ role: 'user', content: [{ type: 'text', text: prompt }] }] };
+        const streamPromise = model.doStream(params);
+        return {
+          get textStream() {
+            return (async function* () {
+              const { stream } = await streamPromise;
+              const reader = stream.getReader();
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                if (value && value.type === 'text-delta') yield value.textDelta;
+              }
+            })();
+          },
+        };
+      }
+      return { wrapLanguageModel, generateText, streamText };
+    }
     if (request === 'weflayr') {
       return _origLoad.call(this, path.resolve(__dirname, '../src/index.js'), parent, isMain);
     }
@@ -81,6 +147,7 @@ const TEST_CREDS = {
 // 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/vercel-ai-middleware')];
   delete require.cache[require.resolve('../src/index')];
   return require('../src/index');
 }
@@ -804,3 +871,232 @@ test('snippet mastra_stream: stream_start + after emitted, model/usage in after
   assert.equal(after.tags.customer_id, '42');
 });
 
+// ---------------------------------------------------------------------------
+// Vercel AI middleware — behavioural
+// ---------------------------------------------------------------------------
+
+test('weflayr_vercel_ai_middleware: wrapGenerate sends before + after with model and tags', async () => {
+  const { weflayr_setup, weflayr_vercel_ai_middleware } = freshSDK();
+
+  weflayr_setup({ ...TEST_CREDS });
+
+  const middleware = weflayr_vercel_ai_middleware({
+    model: 'openai/gpt-4o-mini',
+    tags:  { feature: 'chat' },
+  });
+
+  const sent = await captureHttp(async () => {
+    await middleware.wrapGenerate({
+      doGenerate: async () => ({
+        text: 'Hello!',
+        usage: { promptTokens: 10, completionTokens: 5 },
+        finishReason: 'stop',
+        rawCall: {}, rawResponse: {}, warnings: [],
+      }),
+      params: {},
+      model:  {},
+    });
+  });
+
+  assert.ok(sent.some(e => e.event_type === 'before'), 'before event sent');
+  assert.ok(sent.some(e => e.event_type === 'after'),  'after event sent');
+  const before = sent.find(e => e.event_type === 'before');
+  assert.equal(before.method,        'vercel.generate');
+  assert.equal(before.args.model,    'openai/gpt-4o-mini');
+  assert.equal(before.tags.feature,  'chat');
+  const after = sent.find(e => e.event_type === 'after');
+  assert.deepEqual(after.response.usage, { promptTokens: 10, completionTokens: 5 });
+  assert.equal(after.response.finish_reason, 'stop');
+  assert.ok(after.elapsed_ms >= 0);
+});
+
+test('weflayr_vercel_ai_middleware: wrapStream sends before + stream_start + after with usage', async () => {
+  const { weflayr_setup, weflayr_vercel_ai_middleware } = freshSDK();
+
+  weflayr_setup({ ...TEST_CREDS });
+
+  const middleware = weflayr_vercel_ai_middleware({
+    model: 'openai/gpt-4o-mini',
+    tags:  { feature: 'chat' },
+  });
+
+  const sent = await captureHttp(async () => {
+    const { stream } = await middleware.wrapStream({
+      doStream: async () => ({
+        stream: new ReadableStream({
+          start(ctrl) {
+            ctrl.enqueue({ type: 'text-delta', textDelta: 'Hello!' });
+            ctrl.enqueue({ type: 'finish', finishReason: 'stop', usage: { promptTokens: 10, completionTokens: 5 } });
+            ctrl.close();
+          },
+        }),
+        rawCall: {}, rawResponse: {}, warnings: [],
+      }),
+      params: {},
+      model:  {},
+    });
+
+    const reader = stream.getReader();
+    while (true) {
+      const { done } = await reader.read();
+      if (done) break;
+    }
+  });
+
+  const types = sent.map(e => e.event_type);
+  assert.ok(types.includes('before'),       'before event sent');
+  assert.ok(types.includes('stream_start'), 'stream_start event sent');
+  assert.ok(types.includes('after'),        'after event sent');
+  const after = sent.find(e => e.event_type === 'after');
+  assert.equal(after.method, 'vercel.stream');
+  assert.deepEqual(after.response.usage, { promptTokens: 10, completionTokens: 5 });
+  assert.equal(after.response.finish_reason, 'stop');
+});
+
+test('weflayr_vercel_ai_middleware: weflayr_propagate tags appear in events', async () => {
+  const { weflayr_setup, weflayr_vercel_ai_middleware, weflayr_propagate } = freshSDK();
+
+  weflayr_setup({ ...TEST_CREDS });
+  weflayr_propagate('customer_id', 'acme-corp');
+
+  const middleware = weflayr_vercel_ai_middleware({ model: 'openai/gpt-4o-mini' });
+
+  const sent = await captureHttp(async () => {
+    await middleware.wrapGenerate({
+      doGenerate: async () => ({ text: 'ok', usage: { promptTokens: 1, completionTokens: 1 }, finishReason: 'stop', rawCall: {}, rawResponse: {}, warnings: [] }),
+      params: {},
+      model:  {},
+    });
+  });
+
+  const before = sent.find(e => e.event_type === 'before');
+  assert.equal(before.tags.customer_id, 'acme-corp');
+  const after = sent.find(e => e.event_type === 'after');
+  assert.equal(after.tags.customer_id, 'acme-corp');
+});
+
+// ---------------------------------------------------------------------------
+// Vercel AI middleware — documentation snippets
+// @ai-sdk/openai-compatible and ai are faked by Module._load at top of file.
+// ---------------------------------------------------------------------------
+
+test('snippet vercel_ai_setup: before+after via generateText, method and args correct', async () => {
+  freshSDK();
+  setSnippetEnv();
+
+  const sent = await captureHttp(async () => {
+    // SNIPPET_START: vercel_ai_setup
+    const { weflayr_setup, weflayr_vercel_ai_middleware } = require('weflayr');
+    const { wrapLanguageModel, generateText } = require('ai');
+    const { createOpenAICompatible } = require('@ai-sdk/openai-compatible');
+
+    weflayr_setup({
+      intake_url:    process.env.WEFLAYR_INTAKE_URL,
+      client_id:     process.env.WEFLAYR_CLIENT_ID,
+      client_secret: process.env.WEFLAYR_CLIENT_SECRET,
+    });
+
+    const provider = createOpenAICompatible({
+      name:    'openai',
+      baseURL: 'https://api.openai.com/v1',
+      headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` },
+    });
+
+    const model = wrapLanguageModel({
+      model: provider('gpt-4o-mini'),
+      middleware: weflayr_vercel_ai_middleware({
+        model: 'openai/gpt-4o-mini',
+        tags:  { env: 'production' },
+      }),
+    });
+
+    await generateText({ model, prompt: 'Hello!' });
+    // SNIPPET_END: vercel_ai_setup
+  });
+
+  assert.ok(sent.some(e => e.event_type === 'before'), 'before event sent');
+  assert.ok(sent.some(e => e.event_type === 'after'),  'after event sent');
+  const before = sent.find(e => e.event_type === 'before');
+  assert.equal(before.method,       'vercel.generate');
+  assert.equal(before.args.model,   'openai/gpt-4o-mini');
+  assert.equal(before.tags.env,     'production');
+  const after = sent.find(e => e.event_type === 'after');
+  assert.ok(after.response.usage, 'usage in after event');
+  assert.ok(after.elapsed_ms >= 0);
+});
+
+test('snippet vercel_ai_propagate: propagated customer_id in before+after events', async () => {
+  const { weflayr_setup, weflayr_vercel_ai_middleware } = freshSDK();
+  setSnippetEnv();
+
+  const { wrapLanguageModel, generateText } = require('ai');
+  const { createOpenAICompatible } = require('@ai-sdk/openai-compatible');
+
+  weflayr_setup({ ...TEST_CREDS });
+
+  const provider = createOpenAICompatible({ name: 'openai', baseURL: 'https://api.openai.com/v1', headers: {} });
+  const model = wrapLanguageModel({
+    model: provider('gpt-4o-mini'),
+    middleware: weflayr_vercel_ai_middleware({ model: 'openai/gpt-4o-mini' }),
+  });
+
+  const sent = await captureHttp(async () => {
+    // SNIPPET_START: vercel_ai_propagate
+    const { weflayr_propagate } = require('weflayr');
+
+    weflayr_propagate('customer_id', 'acme-corp');
+    await generateText({ model, prompt: 'Hello!' });
+    // SNIPPET_END: vercel_ai_propagate
+  });
+
+  const before = sent.find(e => e.event_type === 'before');
+  assert.ok(before, 'before event sent');
+  assert.equal(before.tags.customer_id, 'acme-corp');
+  const after = sent.find(e => e.event_type === 'after');
+  assert.equal(after.tags.customer_id, 'acme-corp');
+});
+
+test('snippet vercel_ai_stream: before + stream_start + after via streamText', async () => {
+  freshSDK();
+  setSnippetEnv();
+
+  const sent = await captureHttp(async () => {
+    // SNIPPET_START: vercel_ai_stream
+    const { weflayr_setup, weflayr_vercel_ai_middleware } = require('weflayr');
+    const { wrapLanguageModel, streamText } = require('ai');
+    const { createOpenAICompatible } = require('@ai-sdk/openai-compatible');
+
+    weflayr_setup({
+      intake_url:    process.env.WEFLAYR_INTAKE_URL,
+      client_id:     process.env.WEFLAYR_CLIENT_ID,
+      client_secret: process.env.WEFLAYR_CLIENT_SECRET,
+    });
+
+    const provider = createOpenAICompatible({
+      name:    'openai',
+      baseURL: 'https://api.openai.com/v1',
+      headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` },
+    });
+
+    const model = wrapLanguageModel({
+      model: provider('gpt-4o-mini'),
+      middleware: weflayr_vercel_ai_middleware({
+        model: 'openai/gpt-4o-mini',
+        tags:  { feature: 'chat' },
+      }),
+    });
+
+    const { textStream } = streamText({ model, prompt: 'Hello!' });
+    for await (const _chunk of textStream) {}
+    // SNIPPET_END: vercel_ai_stream
+  });
+
+  const types = sent.map(e => e.event_type);
+  assert.ok(types.includes('before'),       'before event sent');
+  assert.ok(types.includes('stream_start'), 'stream_start event sent');
+  assert.ok(types.includes('after'),        'after event sent');
+  const after = sent.find(e => e.event_type === 'after');
+  assert.equal(after.method,       'vercel.stream');
+  assert.equal(after.tags.feature, 'chat');
+  assert.ok(after.response.usage,  'usage in after event');
+});