weflayr 0.20.6 → 0.22.0

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

@@ -0,0 +1,102 @@
+'use strict';
+
+// Tests for the Bedrock cached-prompt token complement. It wraps the primary
+// instrumentor's `_wrapPromise(span, promise, modelId)` to read Nova's cache-token
+// counts off the decoded InvokeModel response body and stamp them as
+// gen_ai.usage.cache_* attributes.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  BedrockPromptCachingInstrumentor,
+} = require('../../../src/instrumentation/bedrock/get_cache_telemetry');
+
+function fakeSpan() {
+  const attrs = {};
+  return {
+    attrs,
+    isRecording: () => true,
+    setAttribute(key, value) {
+      attrs[key] = value;
+    },
+  };
+}
+
+function encode(obj) {
+  return new TextEncoder().encode(JSON.stringify(obj));
+}
+
+// Pass-through original: resolve to whatever promise it was handed.
+function passthroughInstrumentation() {
+  return { _wrapPromise: (_span, promise) => Promise.resolve(promise) };
+}
+
+test('stamps cache read/write from a buffered InvokeModel body', async () => {
+  const instrumentation = passthroughInstrumentation();
+  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
+
+  const span = fakeSpan();
+  const body = encode({
+    usage: { cacheReadInputTokenCount: 100, cacheWriteInputTokenCount: 1300 },
+  });
+  await instrumentation._wrapPromise(span, Promise.resolve({ body }), 'amazon.nova-micro-v1:0');
+
+  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], 100);
+  assert.equal(span.attrs['gen_ai.usage.cache_creation_input_tokens'], 1300);
+});
+
+test('sets nothing when cache counts are zero', async () => {
+  const instrumentation = passthroughInstrumentation();
+  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
+
+  const span = fakeSpan();
+  const body = encode({ usage: { cacheReadInputTokenCount: 0, cacheWriteInputTokenCount: 0 } });
+  await instrumentation._wrapPromise(span, Promise.resolve({ body }), 'm');
+
+  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], undefined);
+  assert.equal(span.attrs['gen_ai.usage.cache_creation_input_tokens'], undefined);
+});
+
+test('skips a streamed (async-iterable) body without consuming it', async () => {
+  const instrumentation = passthroughInstrumentation();
+  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
+
+  const span = fakeSpan();
+  let consumed = false;
+  const body = (async function* () {
+    consumed = true;
+    yield {};
+  })();
+  await instrumentation._wrapPromise(span, Promise.resolve({ body }), 'm');
+
+  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], undefined);
+  assert.equal(consumed, false);
+});
+
+test('stamps cache from the streamed metadata chunk and calls the original', () => {
+  const calls = [];
+  const instrumentation = {
+    _handleNovaStreamingMetadata(span, parsed) {
+      calls.push(parsed);
+    },
+  };
+  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
+
+  const span = fakeSpan();
+  instrumentation._handleNovaStreamingMetadata(span, {
+    metadata: {
+      usage: { inputTokens: 3, cacheReadInputTokenCount: 1458, cacheWriteInputTokenCount: 0 },
+    },
+  });
+
+  assert.equal(span.attrs['gen_ai.usage.cache_read_input_tokens'], 1458);
+  assert.equal(span.attrs['gen_ai.usage.cache_creation_input_tokens'], undefined);
+  assert.equal(calls.length, 1);
+});
+
+test('is a no-op when the instrumentor has no _wrapPromise', () => {
+  const instrumentation = {};
+  new BedrockPromptCachingInstrumentor().instrument(instrumentation);
+  assert.equal(instrumentation._wrapPromise, undefined);
+});

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_chat_telemetry.test.js

@@ -0,0 +1,148 @@
+'use strict';
+
+// Tests for the Cohere chat token-usage enrichment complement.
+//
+// The cohere-ai v1 `CohereClient` is stubbed with an internal `__chat` method
+// that mirrors the SDK shape — resolving to `{ data: { meta: { billedUnits } } }`
+// — so the complement can be exercised without network access or the dependency
+// installed. The complement enriches whichever span is active when `__chat` runs
+// (in production, the span traceloop opens around the public `chat`), so the
+// tests start a span and make it active before invoking `__chat`.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const Module = require('node:module');
+
+const { trace, context } = require('@opentelemetry/api');
+const {
+  BasicTracerProvider,
+  InMemorySpanExporter,
+  SimpleSpanProcessor,
+} = require('@opentelemetry/sdk-trace-base');
+const { AsyncLocalStorageContextManager } = require('@opentelemetry/context-async-hooks');
+
+const {
+  CohereChatTokenUsageInstrumentor,
+} = require('../../../src/instrumentation/cohere/get_chat_telemetry');
+
+const CLIENT_MODULE = 'cohere-ai/Client';
+
+const exporter = new InMemorySpanExporter();
+trace.setGlobalTracerProvider(
+  new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
+);
+context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
+const tracer = trace.getTracer('test');
+
+class StubCohereClient {
+  __chat(request = {}) {
+    if (request.model === 'boom') return Promise.reject(new Error('api error'));
+    return Promise.resolve({
+      data: { text: 'hi', meta: { billedUnits: { inputTokens: 7, outputTokens: 3 } } },
+    });
+  }
+}
+
+function instrumented() {
+  const stubs = { [CLIENT_MODULE]: { CohereClient: StubCohereClient } };
+  const origResolve = Module._resolveFilename;
+  Module._resolveFilename = function patched(request, ...rest) {
+    if (request in stubs) return request;
+    return origResolve.call(this, request, ...rest);
+  };
+  for (const [moduleId, exports] of Object.entries(stubs)) {
+    require.cache[moduleId] = { id: moduleId, filename: moduleId, loaded: true, exports };
+  }
+
+  const instrumentor = new CohereChatTokenUsageInstrumentor();
+  instrumentor.instrument();
+
+  return () => {
+    instrumentor.uninstrument();
+    Module._resolveFilename = origResolve;
+    for (const moduleId of Object.keys(stubs)) delete require.cache[moduleId];
+    exporter.reset();
+  };
+}
+
+// Runs `__chat` inside an active span, mirroring the context traceloop sets up
+// around the public `chat`, and returns the finished span.
+async function callChatWithinSpan(client, request) {
+  const span = tracer.startSpan('cohere.chat');
+  await context.with(trace.setSpan(context.active(), span), () => client.__chat(request));
+  span.end();
+  return exporter.getFinishedSpans().find((finished) => finished.name === 'cohere.chat');
+}
+
+test('enriches the active chat span with input and output tokens', async () => {
+  const teardown = instrumented();
+  try {
+    const client = new StubCohereClient();
+    const span = await callChatWithinSpan(client, { model: 'command-r-08-2024', message: 'hi' });
+
+    assert.equal(span.attributes['gen_ai.usage.input_tokens'], 7);
+    assert.equal(span.attributes['gen_ai.usage.output_tokens'], 3);
+  } finally {
+    teardown();
+  }
+});
+
+test('leaves the response unchanged', async () => {
+  const teardown = instrumented();
+  try {
+    const client = new StubCohereClient();
+    let result;
+    const span = tracer.startSpan('cohere.chat');
+    await context.with(trace.setSpan(context.active(), span), async () => {
+      result = await client.__chat({ model: 'command-r-08-2024', message: 'hi' });
+    });
+    span.end();
+
+    assert.equal(result.data.text, 'hi');
+    assert.equal(result.data.meta.billedUnits.inputTokens, 7);
+  } finally {
+    teardown();
+  }
+});
+
+test('does nothing when no span is active', async () => {
+  const teardown = instrumented();
+  try {
+    const client = new StubCohereClient();
+    // No active span — must not throw, just pass the response through.
+    const result = await client.__chat({ model: 'command-r-08-2024', message: 'hi' });
+    assert.equal(result.data.meta.billedUnits.outputTokens, 3);
+    assert.equal(exporter.getFinishedSpans().length, 0);
+  } finally {
+    teardown();
+  }
+});
+
+test('propagates errors without enriching the span', async () => {
+  const teardown = instrumented();
+  try {
+    const client = new StubCohereClient();
+    const span = tracer.startSpan('cohere.chat');
+    await assert.rejects(
+      () =>
+        context.with(trace.setSpan(context.active(), span), () =>
+          client.__chat({ model: 'boom', message: 'x' })
+        ),
+      /api error/
+    );
+    span.end();
+
+    const finished = exporter.getFinishedSpans().find((each) => each.name === 'cohere.chat');
+    assert.equal(finished.attributes['gen_ai.usage.input_tokens'], undefined);
+  } finally {
+    teardown();
+  }
+});
+
+test('uninstrument restores the original method', async () => {
+  const teardown = instrumented();
+  const { CohereClient } = require(CLIENT_MODULE);
+  const wrapped = CohereClient.prototype.__chat;
+  teardown();
+  assert.notEqual(CohereClient.prototype.__chat, wrapped);
+});

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

@@ -0,0 +1,132 @@
+'use strict';
+
+// Tests for the bundled Cohere embeddings instrumentor.
+//
+// The cohere-ai v1 `CohereClient` and v2 `V2Client` classes are stubbed with an
+// `embed` method that mirrors the SDK shape — resolving to a response carrying
+// `meta.billedUnits.inputTokens` — so the instrumentor can be exercised without
+// network access or the dependency installed.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const Module = require('node:module');
+
+const { trace, SpanStatusCode } = require('@opentelemetry/api');
+const {
+  BasicTracerProvider,
+  InMemorySpanExporter,
+  SimpleSpanProcessor,
+} = require('@opentelemetry/sdk-trace-base');
+
+const {
+  CohereEmbeddingsInstrumentor,
+} = require('../../../src/instrumentation/cohere/get_embeddings_telemetry');
+
+const V1_MODULE = 'cohere-ai/Client';
+const V2_MODULE = 'cohere-ai/api/resources/v2/client/Client';
+
+const exporter = new InMemorySpanExporter();
+trace.setGlobalTracerProvider(
+  new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
+);
+
+class StubCohereClient {
+  embed(request = {}) {
+    if (request.model === 'boom') return Promise.reject(new Error('api error'));
+    return Promise.resolve({ embeddings: [[0.1]], meta: { billedUnits: { inputTokens: 8 } } });
+  }
+}
+
+class StubV2Client {
+  embed(_request = {}) {
+    return Promise.resolve({
+      embeddings: { float: [[0.2]] },
+      meta: { billedUnits: { inputTokens: 5 } },
+    });
+  }
+}
+
+function instrumented() {
+  const stubs = {
+    [V1_MODULE]: { CohereClient: StubCohereClient },
+    [V2_MODULE]: { V2Client: StubV2Client },
+  };
+  const origResolve = Module._resolveFilename;
+  Module._resolveFilename = function patched(request, ...rest) {
+    if (request in stubs) return request;
+    return origResolve.call(this, request, ...rest);
+  };
+  for (const [moduleId, exports] of Object.entries(stubs)) {
+    require.cache[moduleId] = { id: moduleId, filename: moduleId, loaded: true, exports };
+  }
+
+  const instrumentor = new CohereEmbeddingsInstrumentor();
+  instrumentor.instrument();
+
+  return () => {
+    instrumentor.uninstrument();
+    Module._resolveFilename = origResolve;
+    for (const moduleId of Object.keys(stubs)) delete require.cache[moduleId];
+    exporter.reset();
+  };
+}
+
+test('v1 embed emits genai span with input tokens', async () => {
+  const teardown = instrumented();
+  try {
+    const client = new StubCohereClient();
+    const result = await client.embed({ model: 'embed-english-v3.0', texts: ['hi'] });
+    assert.equal(result.meta.billedUnits.inputTokens, 8);
+
+    const [span] = exporter.getFinishedSpans();
+    assert.equal(span.name, 'embeddings');
+    assert.equal(span.attributes['gen_ai.system'], 'Cohere');
+    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();
+  }
+});
+
+test('v2 embed emits genai span with input tokens', async () => {
+  const teardown = instrumented();
+  try {
+    const client = new StubV2Client();
+    await client.embed({ model: 'embed-v4.0', texts: ['hi'] });
+
+    const [span] = exporter.getFinishedSpans();
+    assert.equal(span.attributes['gen_ai.request.model'], 'embed-v4.0');
+    assert.equal(span.attributes['gen_ai.usage.input_tokens'], 5);
+  } finally {
+    teardown();
+  }
+});
+
+test('embed records error status on failure', async () => {
+  const teardown = instrumented();
+  try {
+    const client = new StubCohereClient();
+    await assert.rejects(() => client.embed({ model: 'boom', texts: ['x'] }), /api error/);
+
+    const [span] = exporter.getFinishedSpans();
+    assert.equal(span.status.code, SpanStatusCode.ERROR);
+  } finally {
+    teardown();
+  }
+});
+
+test('uninstrument restores original methods', async () => {
+  const teardown = instrumented();
+  try {
+    const client = new StubCohereClient();
+    await client.embed({ model: 'embed-english-v3.0', texts: ['x'] });
+    assert.equal(exporter.getFinishedSpans().length, 1);
+  } finally {
+    teardown();
+  }
+});

package/tests/instrumentation/{elevenlabs.test.js → elevenlabs/full_instrumentation.test.js}

@@ -20,7 +20,9 @@ const {
   SimpleSpanProcessor,
 } = require('@opentelemetry/sdk-trace-base');
 
-const { ElevenLabsInstrumentor } = require('../../src/instrumentation/elevenlabs');
+const {
+  ElevenLabsInstrumentor,
+} = require('../../../src/instrumentation/elevenlabs/full_instrumentation');
 
 const TTS_CLIENT_MODULE = '@elevenlabs/elevenlabs-js/api/resources/textToSpeech/client/Client';
 const STT_CLIENT_MODULE = '@elevenlabs/elevenlabs-js/api/resources/speechToText/client/Client';
@@ -33,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({
@@ -62,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 = {}) {
@@ -70,7 +78,7 @@ class StubTextToSpeechClient {
   }
 
   streamWithTimestamps(_voiceId, _request = {}) {
-    return Promise.resolve(asyncIterableOf([{ audioBase64: 'eA==' }]));
+    return Promise.resolve(asyncIterableOf(TTS_OBJECT_CHUNKS));
   }
 
   convertWithTimestamps(_voiceId, _request = {}) {
@@ -134,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');
@@ -184,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');