weflayr 0.21.0 → 0.22.0

package/tests/index.test.js

@@ -184,6 +184,54 @@ test('buildExporter strips trailing slash on baseUrl', () => {
   assert.equal(_exporterParams(exporter).url, 'https://api.weflayr.com/');
 });
 
+test('buildExporter warns on every export error when warnOnExportError is true', async () => {
+  const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
+  const origExport = OTLPTraceExporter.prototype.export;
+  OTLPTraceExporter.prototype.export = function (spans, cb) {
+    cb({ code: 1, error: { code: 401, message: 'Unauthorized' } });
+  };
+  const warnings = [];
+  const origWarn = console.warn;
+  console.warn = (...args) => warnings.push(args.join(' '));
+  try {
+    const exporter = buildExporter({
+      baseUrl: 'https://api.weflayr.com',
+      apiKey: 'bad',
+      warnOnExportError: true,
+    });
+    await new Promise((resolve) => exporter.export([], resolve));
+    await new Promise((resolve) => exporter.export([], resolve));
+    assert.equal(warnings.filter((w) => w.includes('[weflayr]')).length, 2);
+  } finally {
+    OTLPTraceExporter.prototype.export = origExport;
+    console.warn = origWarn;
+  }
+});
+
+test('buildExporter does not warn when warnOnExportError is false', async () => {
+  const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
+  const origExport = OTLPTraceExporter.prototype.export;
+  OTLPTraceExporter.prototype.export = function (spans, cb) {
+    cb({ code: 1, error: { code: 401, message: 'Unauthorized' } });
+  };
+  const warnings = [];
+  const origWarn = console.warn;
+  console.warn = (...args) => warnings.push(args.join(' '));
+  try {
+    const exporter = buildExporter({
+      baseUrl: 'https://api.weflayr.com',
+      apiKey: 'bad',
+      warnOnExportError: false,
+    });
+    await new Promise((resolve) => exporter.export([], resolve));
+    await new Promise((resolve) => exporter.export([], resolve));
+    assert.equal(warnings.filter((w) => w.includes('[weflayr]')).length, 0);
+  } finally {
+    OTLPTraceExporter.prototype.export = origExport;
+    console.warn = origWarn;
+  }
+});
+
 // ── span-filter ───────────────────────────────────────────────────────────────
 
 test('isDefaultExportSpan accepts spans with gen_ai.* attributes', () => {
@@ -287,6 +335,60 @@ test('WeflayrSpanProcessor applies mask before export', async () => {
   assert.equal(span.attributes['gen_ai.prompt'], '[REDACTED]');
 });
 
+test('WeflayrSpanProcessor strips message content when capture disabled', async () => {
+  // Instrumentors gate content on their own env vars (openllmetry captures by
+  // default), so the processor itself must drop message content when
+  // captureMessageContent=false recorded "false" in the env var.
+  process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = 'false';
+  try {
+    const exporter = makeExporterStub();
+    const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
+    const span = makeFakeSpan({
+      attributes: {
+        'gen_ai.system': 'openai',
+        'gen_ai.input.messages': '[{"role": "user"}]',
+        'gen_ai.output.messages': '[{"role": "assistant"}]',
+        'gen_ai.system_instructions': '[{"type": "text"}]',
+        'gen_ai.prompt.0.content': 'Hi Noe',
+        'gen_ai.completion.0.content': 'Hello!',
+        'gen_ai.usage.input_tokens': 12,
+      },
+    });
+    proc.onEnd(span);
+    await proc.forceFlush();
+    assert.equal(span.attributes['gen_ai.system'], 'openai');
+    assert.equal(span.attributes['gen_ai.usage.input_tokens'], 12);
+    for (const key of Object.keys(span.attributes)) {
+      assert.ok(!key.startsWith('gen_ai.prompt'), `unexpected ${key}`);
+      assert.ok(!key.startsWith('gen_ai.completion'), `unexpected ${key}`);
+    }
+    assert.ok(!('gen_ai.input.messages' in span.attributes));
+    assert.ok(!('gen_ai.output.messages' in span.attributes));
+    assert.ok(!('gen_ai.system_instructions' in span.attributes));
+  } finally {
+    delete process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT;
+  }
+});
+
+test('WeflayrSpanProcessor keeps message content when capture enabled', async () => {
+  process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = 'true';
+  try {
+    const exporter = makeExporterStub();
+    const proc = new WeflayrSpanProcessor({ exporter, exportMode: 'immediate' });
+    const span = makeFakeSpan({
+      attributes: {
+        'gen_ai.system': 'openai',
+        'gen_ai.input.messages': '[{"role": "user"}]',
+      },
+    });
+    proc.onEnd(span);
+    await proc.forceFlush();
+    assert.equal(span.attributes['gen_ai.input.messages'], '[{"role": "user"}]');
+  } finally {
+    delete process.env.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT;
+  }
+});
+
 // ── propagateMetadata ────────────────────────────────────────────────────────
 
 function _makeMetadataHarness() {

package/tests/instrumentation/anthropic/get_cache_and_reasoning_telemetry.test.js

@@ -118,6 +118,39 @@ test('stamps cache + raw input from the streamed message_start usage', async ()
   assert.equal(span.attrs['gen_ai.usage.input_tokens'], 10);
 });
 
+test('re-yields every stream chunk unchanged — no telemetry collision with the payload', async () => {
+  const emitted = [
+    {
+      type: 'message_start',
+      message: { usage: { input_tokens: 10, cache_read_input_tokens: 5270 } },
+    },
+    { type: 'content_block_delta', delta: { text: 'O' } },
+    { type: 'content_block_delta', delta: { text: 'K' } },
+  ];
+  const instrumentation = {
+    _endSpan() {},
+    _streamingWrapPromise() {
+      return (async function* () {
+        for (const chunk of emitted) yield chunk;
+      })();
+    },
+  };
+  new AnthropicPromptCachingInstrumentor().instrument(instrumentation);
+
+  const span = fakeSpan();
+  const collected = [];
+  for await (const chunk of instrumentation._streamingWrapPromise('client', 'mod', { span })) {
+    collected.push(chunk);
+  }
+
+  // Same count, order, and object identity: observeCache re-yields each chunk by
+  // reference without copying or mutating it.
+  assert.equal(collected.length, emitted.length);
+  collected.forEach((chunk, index) => assert.equal(chunk, emitted[index]));
+  // …while still stamping cache + raw input off the message_start chunk.
+  assert.equal(span.attrs['gen_ai.usage.input_tokens'], 10);
+});
+
 test('is a no-op when the instrumentor has no _endSpan', () => {
   const instrumentation = {};
   new AnthropicPromptCachingInstrumentor().instrument(instrumentation);

package/tests/instrumentation/anthropic/get_streaming_stop_reason_telemetry.test.js

@@ -0,0 +1,117 @@
+'use strict';
+
+// Tests for the Anthropic streamed stop-reason complement.
+//
+// The traceloop instrumentation instance is stubbed the way the real one works:
+// `_streamingWrapPromise` returns `new moduleExports.APIPromise(...)` whose
+// parse step wraps the SDK stream with an accumulating iterator that calls
+// `_endSpan` when exhausted — so the test exercises the complement's APIPromise
+// interposition end to end.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  AnthropicStreamingStopReasonInstrumentor,
+} = require('../../../src/instrumentation/anthropic/get_streaming_stop_reason_telemetry');
+
+class StubStream {
+  constructor(iteratorFactory, controller) {
+    this._iteratorFactory = iteratorFactory;
+    this.controller = controller;
+  }
+
+  [Symbol.asyncIterator]() {
+    return this._iteratorFactory();
+  }
+}
+
+class StubAPIPromise {
+  constructor(client, responsePromise, parseResponse) {
+    this.parsed = parseResponse(client, responsePromise);
+  }
+}
+
+function makeStubInstrumentation() {
+  const finalized = [];
+  return {
+    finalized,
+    _streamingWrapPromise(client, moduleExports, { span, promise }) {
+      const self = this;
+      return new moduleExports.APIPromise(
+        client,
+        promise,
+        async (parseClient, realStreamPromise) => {
+          const realStream = await realStreamPromise;
+          // Mimics traceloop: re-wrap the stream with an accumulating iterator
+          // that finalizes the span once exhausted.
+          return new realStream.constructor(
+            () =>
+              (async function* accumulate() {
+                const result = { stop_reason: null };
+                for await (const chunk of realStream) yield chunk;
+                self._endSpan({ span, result });
+              })(),
+            realStream.controller
+          );
+        }
+      );
+    },
+    _endSpan(args) {
+      finalized.push(args.result);
+    },
+  };
+}
+
+function chunkStream() {
+  return new StubStream(async function* chunks() {
+    yield { type: 'message_start', message: { usage: { input_tokens: 5 } } };
+    yield { type: 'content_block_delta', delta: { type: 'text_delta', text: 'Hello' } };
+    yield {
+      type: 'message_delta',
+      delta: { stop_reason: 'end_turn' },
+      usage: { output_tokens: 3 },
+    };
+    yield { type: 'message_stop' };
+  });
+}
+
+test('injects the streamed stop reason into the result before endSpan', async () => {
+  const instrumentation = makeStubInstrumentation();
+  new AnthropicStreamingStopReasonInstrumentor().instrument(instrumentation);
+
+  const span = { name: 'anthropic.chat' };
+  const apiPromise = instrumentation._streamingWrapPromise(
+    {},
+    { APIPromise: StubAPIPromise },
+    { span, type: 'chat', promise: Promise.resolve(chunkStream()) }
+  );
+
+  const stream = await apiPromise.parsed;
+  const seen = [];
+  for await (const chunk of stream) seen.push(chunk.type);
+
+  assert.deepEqual(seen, ['message_start', 'content_block_delta', 'message_delta', 'message_stop']);
+  assert.equal(instrumentation.finalized.length, 1);
+  assert.equal(instrumentation.finalized[0].stop_reason, 'end_turn');
+});
+
+test('leaves an already-set stop reason untouched', () => {
+  const instrumentation = makeStubInstrumentation();
+  new AnthropicStreamingStopReasonInstrumentor().instrument(instrumentation);
+
+  const span = { name: 'anthropic.chat' };
+  instrumentation._endSpan({ span, result: { stop_reason: 'max_tokens' } });
+  assert.equal(instrumentation.finalized[0].stop_reason, 'max_tokens');
+});
+
+test('uninstrument restores the original methods', () => {
+  const instrumentation = makeStubInstrumentation();
+  const streamOriginal = instrumentation._streamingWrapPromise;
+  const endSpanOriginal = instrumentation._endSpan;
+  const instrumentor = new AnthropicStreamingStopReasonInstrumentor();
+  instrumentor.instrument(instrumentation);
+  instrumentor.uninstrument();
+  assert.equal(instrumentation._streamingWrapPromise, streamOriginal);
+  assert.equal(instrumentation._endSpan, endSpanOriginal);
+});

package/tests/instrumentation/anthropic/get_tool_definitions_telemetry.test.js

@@ -0,0 +1,82 @@
+'use strict';
+
+// Tests for the Anthropic tool-definitions complement.
+//
+// The traceloop instrumentation instance is stubbed with a `startSpan` that
+// returns a fake span, so the wrap can be exercised without the real SDK.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  AnthropicToolDefinitionsInstrumentor,
+} = require('../../../src/instrumentation/anthropic/get_tool_definitions_telemetry');
+
+function makeFakeSpan() {
+  const attributes = {};
+  return {
+    attributes,
+    setAttribute(key, value) {
+      attributes[key] = value;
+    },
+  };
+}
+
+function makeStubInstrumentation() {
+  return {
+    startSpan(request) {
+      const span = makeFakeSpan();
+      span.attributes['gen_ai.request.model'] = request.params.model;
+      return span;
+    },
+  };
+}
+
+const WEATHER_TOOL = {
+  name: 'get_weather',
+  description: 'Get the current weather for a city.',
+  input_schema: { type: 'object', properties: { city: { type: 'string' } } },
+};
+
+test('stamps tool definitions from the request params', () => {
+  const instrumentation = makeStubInstrumentation();
+  const instrumentor = new AnthropicToolDefinitionsInstrumentor();
+  instrumentor.instrument(instrumentation);
+
+  const span = instrumentation.startSpan({
+    type: 'chat',
+    params: { model: 'claude-haiku-4-5', tools: [WEATHER_TOOL] },
+  });
+
+  assert.equal(span.attributes['gen_ai.request.model'], 'claude-haiku-4-5');
+  assert.deepEqual(JSON.parse(span.attributes['gen_ai.tool.definitions']), [WEATHER_TOOL]);
+});
+
+test('no attribute when the request has no tools', () => {
+  const instrumentation = makeStubInstrumentation();
+  new AnthropicToolDefinitionsInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation.startSpan({
+    type: 'chat',
+    params: { model: 'claude-haiku-4-5' },
+  });
+
+  assert.ok(!('gen_ai.tool.definitions' in span.attributes));
+});
+
+test('uninstrument restores the original startSpan', () => {
+  const instrumentation = makeStubInstrumentation();
+  const original = instrumentation.startSpan;
+  const instrumentor = new AnthropicToolDefinitionsInstrumentor();
+  instrumentor.instrument(instrumentation);
+  assert.notEqual(instrumentation.startSpan, original);
+  instrumentor.uninstrument();
+  assert.equal(instrumentation.startSpan, original);
+});
+
+test('is a no-op when the instrumentor has no startSpan', () => {
+  const instrumentor = new AnthropicToolDefinitionsInstrumentor();
+  instrumentor.instrument({});
+  instrumentor.instrument(undefined);
+  instrumentor.uninstrument();
+});

package/tests/instrumentation/bedrock/get_input_message_content_telemetry.test.js

@@ -0,0 +1,89 @@
+'use strict';
+
+// Tests for the Bedrock input-message-content complement.
+//
+// The traceloop instrumentation instance is stubbed with a `_startSpan` that
+// returns a fake span — with or without instrumentor-set input messages — so
+// the wrap's "only when missing" behaviour can be exercised.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  BedrockInputMessageContentInstrumentor,
+} = require('../../../src/instrumentation/bedrock/get_input_message_content_telemetry');
+
+function makeFakeSpan(attributes = {}) {
+  return {
+    attributes,
+    setAttribute(key, value) {
+      attributes[key] = value;
+    },
+  };
+}
+
+function makeStubInstrumentation(spanAttributes) {
+  return {
+    _startSpan() {
+      return makeFakeSpan(spanAttributes);
+    },
+  };
+}
+
+function request(body) {
+  return { params: { input: { modelId: 'model-that-does-not-exist', body } } };
+}
+
+test('stamps input messages when the instrumentor set none', () => {
+  const instrumentation = makeStubInstrumentation({});
+  new BedrockInputMessageContentInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation._startSpan(
+    request(JSON.stringify({ messages: [{ role: 'user', content: [{ text: 'Hello' }] }] }))
+  );
+
+  assert.deepEqual(JSON.parse(span.attributes['gen_ai.input.messages']), [
+    { role: 'user', parts: [{ type: 'text', content: 'Hello' }] },
+  ]);
+});
+
+test('supports the flat inputText schema', () => {
+  const instrumentation = makeStubInstrumentation({});
+  new BedrockInputMessageContentInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation._startSpan(request(JSON.stringify({ inputText: 'Hello' })));
+
+  assert.deepEqual(JSON.parse(span.attributes['gen_ai.input.messages']), [
+    { role: 'user', parts: [{ type: 'text', content: 'Hello' }] },
+  ]);
+});
+
+test('leaves instrumentor-set input messages untouched', () => {
+  const existing = '[{"role":"user","parts":[{"type":"text","content":"from-traceloop"}]}]';
+  const instrumentation = makeStubInstrumentation({ 'gen_ai.input.messages': existing });
+  new BedrockInputMessageContentInstrumentor().instrument(instrumentation);
+
+  const span = instrumentation._startSpan(
+    request(JSON.stringify({ messages: [{ role: 'user', content: [{ text: 'other' }] }] }))
+  );
+
+  assert.equal(span.attributes['gen_ai.input.messages'], existing);
+});
+
+test('no attribute for an unparseable or empty body', () => {
+  const instrumentation = makeStubInstrumentation({});
+  new BedrockInputMessageContentInstrumentor().instrument(instrumentation);
+
+  assert.ok(
+    !('gen_ai.input.messages' in instrumentation._startSpan(request('not-json')).attributes)
+  );
+});
+
+test('uninstrument restores the original startSpan', () => {
+  const instrumentation = makeStubInstrumentation({});
+  const original = instrumentation._startSpan;
+  const instrumentor = new BedrockInputMessageContentInstrumentor();
+  instrumentor.instrument(instrumentation);
+  instrumentor.uninstrument();
+  assert.equal(instrumentation._startSpan, original);
+});

package/tests/instrumentation/bedrock/get_streaming_output_message_telemetry.test.js

@@ -0,0 +1,87 @@
+'use strict';
+
+// Tests for the Bedrock streamed-output message complement.
+//
+// The traceloop instrumentation instance is stubbed with a
+// `_handleNovaStreamingMetadata` no-op; chunks are replayed through the wrap the
+// way the instrumentation's stream loop calls it.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  BedrockStreamingOutputMessageInstrumentor,
+} = require('../../../src/instrumentation/bedrock/get_streaming_output_message_telemetry');
+
+function makeFakeSpan() {
+  const attributes = {};
+  return {
+    attributes,
+    setAttribute(key, value) {
+      attributes[key] = value;
+    },
+  };
+}
+
+function instrumented() {
+  const instrumentation = { _handleNovaStreamingMetadata() {} };
+  const instrumentor = new BedrockStreamingOutputMessageInstrumentor();
+  instrumentor.instrument(instrumentation);
+  return { instrumentation, instrumentor };
+}
+
+test('re-stamps the output message from accumulated stream chunks', () => {
+  const { instrumentation } = instrumented();
+  const span = makeFakeSpan();
+
+  instrumentation._handleNovaStreamingMetadata(span, {
+    contentBlockDelta: { delta: { text: 'Hel' } },
+  });
+  instrumentation._handleNovaStreamingMetadata(span, {
+    contentBlockDelta: { delta: { text: 'lo!' } },
+  });
+  instrumentation._handleNovaStreamingMetadata(span, {
+    messageStop: { stopReason: 'end_turn' },
+  });
+  assert.ok(!('gen_ai.output.messages' in span.attributes), 'set only on the metadata chunk');
+
+  instrumentation._handleNovaStreamingMetadata(span, { metadata: { usage: {} } });
+  assert.deepEqual(JSON.parse(span.attributes['gen_ai.output.messages']), [
+    {
+      role: 'assistant',
+      parts: [{ type: 'text', content: 'Hello!' }],
+      finish_reason: 'stop',
+    },
+  ]);
+});
+
+test('maps max_tokens to length', () => {
+  const { instrumentation } = instrumented();
+  const span = makeFakeSpan();
+  instrumentation._handleNovaStreamingMetadata(span, {
+    contentBlockDelta: { delta: { text: 'OK' } },
+  });
+  instrumentation._handleNovaStreamingMetadata(span, {
+    messageStop: { stopReason: 'max_tokens' },
+  });
+  instrumentation._handleNovaStreamingMetadata(span, { metadata: {} });
+  assert.equal(JSON.parse(span.attributes['gen_ai.output.messages'])[0].finish_reason, 'length');
+});
+
+test('no attribute when no text was streamed', () => {
+  const { instrumentation } = instrumented();
+  const span = makeFakeSpan();
+  instrumentation._handleNovaStreamingMetadata(span, {
+    messageStop: { stopReason: 'end_turn' },
+  });
+  instrumentation._handleNovaStreamingMetadata(span, { metadata: {} });
+  assert.ok(!('gen_ai.output.messages' in span.attributes));
+});
+
+test('uninstrument restores the original handler', () => {
+  const { instrumentation, instrumentor } = instrumented();
+  instrumentor.uninstrument();
+  const span = makeFakeSpan();
+  instrumentation._handleNovaStreamingMetadata(span, { metadata: {} });
+  assert.deepEqual(span.attributes, {});
+});

package/tests/instrumentation/cohere/get_embeddings_telemetry.test.js

@@ -84,6 +84,9 @@ test('v1 embed emits genai span with input tokens', async () => {
     assert.equal(span.attributes['gen_ai.operation.name'], 'embeddings');
     assert.equal(span.attributes['gen_ai.request.model'], 'embed-english-v3.0');
     assert.equal(span.attributes['gen_ai.usage.input_tokens'], 8);
+    assert.deepEqual(JSON.parse(span.attributes['gen_ai.input.messages']), [
+      { role: 'user', parts: [{ type: 'text', content: 'hi' }] },
+    ]);
     assert.equal(span.status.code, SpanStatusCode.UNSET);
   } finally {
     teardown();

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

@@ -35,6 +35,12 @@ trace.setGlobalTracerProvider(
   new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
 );
 
+// The exact chunk objects the streaming stubs yield. Shared so the passthrough
+// assertions can compare object identity — proof our proxies re-emit the user's
+// chunks without copying or mutating them.
+const TTS_BYTE_CHUNKS = [Buffer.from('a'), Buffer.from('b')];
+const TTS_OBJECT_CHUNKS = [{ audioBase64: 'eA==' }, { audioBase64: 'YmI=' }];
+
 function readableOf(chunks) {
   let index = 0;
   return new ReadableStream({
@@ -64,7 +70,7 @@ function asyncIterableOf(chunks) {
 class StubTextToSpeechClient {
   convert(_voiceId, request = {}) {
     if (request.text === 'boom') return Promise.resolve(failingReadable(new Error('api error')));
-    return Promise.resolve(readableOf([Buffer.from('a'), Buffer.from('b')]));
+    return Promise.resolve(readableOf(TTS_BYTE_CHUNKS));
   }
 
   stream(_voiceId, _request = {}) {
@@ -72,7 +78,7 @@ class StubTextToSpeechClient {
   }
 
   streamWithTimestamps(_voiceId, _request = {}) {
-    return Promise.resolve(asyncIterableOf([{ audioBase64: 'eA==' }]));
+    return Promise.resolve(asyncIterableOf(TTS_OBJECT_CHUNKS));
   }
 
   convertWithTimestamps(_voiceId, _request = {}) {
@@ -136,7 +142,11 @@ test('convert emits genai span with char count', async () => {
   try {
     const client = new StubTextToSpeechClient();
     const stream = await client.convert('voice', { text: 'hello world', modelId: 'eleven_v2' });
-    assert.deepEqual(await drain(stream), [Buffer.from('a'), Buffer.from('b')]);
+    // Same count, order, and object identity: the byte-stream proxy re-emits each
+    // chunk by reference — no telemetry collision with the caller's audio.
+    const collected = await drain(stream);
+    assert.equal(collected.length, TTS_BYTE_CHUNKS.length);
+    collected.forEach((chunk, index) => assert.equal(chunk, TTS_BYTE_CHUNKS[index]));
 
     const [span] = exporter.getFinishedSpans();
     assert.equal(span.name, 'text_to_speech');
@@ -186,7 +196,11 @@ test('stream with timestamps emits span with char count', async () => {
   try {
     const client = new StubTextToSpeechClient();
     const stream = await client.streamWithTimestamps('voice', { text: 'hello', modelId: 'm' });
-    assert.deepEqual(await drainIterable(stream), [{ audioBase64: 'eA==' }]);
+    // Same count, order, and object identity: the object-stream proxy re-yields
+    // each chunk by reference — no telemetry collision with the caller's payload.
+    const collected = await drainIterable(stream);
+    assert.equal(collected.length, TTS_OBJECT_CHUNKS.length);
+    collected.forEach((chunk, index) => assert.equal(chunk, TTS_OBJECT_CHUNKS[index]));
 
     const [span] = exporter.getFinishedSpans();
     assert.equal(span.name, 'text_to_speech');

package/tests/instrumentation/google/get_embeddings_telemetry.test.js

@@ -60,6 +60,9 @@ test('embeddings emits genai span with character count and stripped model', asyn
     // The "models/" prefix is stripped to match the chat path.
     assert.equal(span.attributes['gen_ai.request.model'], 'text-embedding-004');
     assert.equal(span.attributes['gen_ai.usage.input_characters'], 'hello world'.length);
+    assert.deepEqual(JSON.parse(span.attributes['gen_ai.input.messages']), [
+      { role: 'user', parts: [{ type: 'text', content: 'hello world' }] },
+    ]);
     assert.equal(span.status.code, SpanStatusCode.UNSET);
   } finally {
     teardown();

package/tests/instrumentation/google/set_telemetry_attributes.test.js

@@ -25,6 +25,14 @@ const {
 
 const GENAI_MODULE = '@google/genai';
 
+// The exact chunk objects the streaming stub yields. Shared so the passthrough
+// test can assert object identity — proof our wrapper re-yields the user's chunks
+// without copying or mutating them. The last chunk carries the streamed usage.
+const STREAM_CHUNKS = [
+  { text: 'hello ' },
+  { text: 'world', usageMetadata: { cachedContentTokenCount: 32 } },
+];
+
 const exporter = new InMemorySpanExporter();
 trace.setGlobalTracerProvider(
   new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
@@ -51,7 +59,7 @@ class StubModels {
   generateContentStreamInternal() {
     return Promise.resolve(
       (async function* () {
-        yield { text: 'ok' };
+        for (const chunk of STREAM_CHUNKS) yield chunk;
       })()
     );
   }
@@ -185,3 +193,27 @@ test('streaming sets provider only and uninstrument restores methods', async ()
   const client = new StubModels();
   assert.equal(typeof client.generateContentInternal, 'function');
 });
+
+test('streaming re-yields the user chunks unchanged and stamps cache off the stream', async () => {
+  const teardown = instrumented();
+  try {
+    const client = new StubModels();
+    client.apiClient = { isVertexAI: () => false };
+    const collected = [];
+    const span = await withActiveSpan(async () => {
+      const stream = await client.generateContentStreamInternal({ model: 'm' });
+      for await (const chunk of stream) collected.push(chunk);
+    });
+    // Same count, order, and object identity: observeCache re-yields each chunk
+    // by reference — no telemetry collision with the caller's payload.
+    assert.equal(collected.length, STREAM_CHUNKS.length);
+    collected.forEach((chunk, index) => {
+      assert.equal(chunk, STREAM_CHUNKS[index]);
+      assert.equal(chunk.text, STREAM_CHUNKS[index].text);
+    });
+    // The wrapper still ran: cache tokens from the final chunk landed on the span.
+    assert.equal(span.attributes['gen_ai.usage.cache_read_input_tokens'], 32);
+  } finally {
+    teardown();
+  }
+});