weflayr 0.20.6 → 0.22.0

package/index.d.ts

@@ -62,7 +62,7 @@ export const AIProviderName: {
 export type AIProviderName = (typeof AIProviderName)[keyof typeof AIProviderName];
 
 export interface SetupOptions {
-  /** Weflayr API key. The server resolves your client_id from this token. */
+  /** Weflayr API key. The server resolves your project_uuid from this token. */
   apiKey: string;
   /** Override the intake base URL. Defaults to WEFLAYR_BASE_URL or https://api.weflayr.com. */
   baseUrl?: string;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "weflayr",
-  "version": "0.20.6",
+  "version": "0.22.0",
   "description": "Weflayr Node.js SDK — instrument any LLM client via JS Proxy",
   "main": "src/index.js",
   "types": "index.d.ts",
   "scripts": {
-    "test": "node --test tests/index.test.js tests/instrumentation/elevenlabs.test.js",
+    "test": "node --test",
     "lint": "eslint src tests",
     "lint:fix": "eslint src tests --fix",
     "format": "prettier --write src tests",

package/src/auto-instrument.js

@@ -4,39 +4,69 @@ const { registerInstrumentations } = require('@opentelemetry/instrumentation');
 
 const { debug } = require('./logger');
 const { setup, _state } = require('./setup');
-const { patchOpenAIStreamingUsage } = require('./otel/openai-streaming-usage');
 
 const AiSdk = Object.freeze({
   OPENAI: 'openai',
   ANTHROPIC: 'anthropic',
   BEDROCK: 'bedrock',
-  AZURE: 'azure',
   COHERE: 'cohere',
-  TOGETHER: 'together',
-  GOOGLE_VERTEX: 'google-vertex',
   GOOGLE_GENAI: 'google-genai',
   ELEVENLABS: 'elevenlabs',
 });
 
 // Allowed values for `propagateMetadata({ providerName })`: every SDK the
 // auto-instrumentation registry knows, plus providers reached via the OpenAI
-// SDK on the wire but reported as themselves (e.g. Vercel AI Gateway proxies
-// to OpenAI/Anthropic but should be reported as the gateway).
+// SDK on the wire but reported as themselves
+// Those are instrumented via `autoInstrument({ aiSdks: 'openai' })` and labelled
+// through `propagateMetadata({ providerName })`, not their own instrumentor.
 const AIProviderName = Object.freeze({
   ...AiSdk,
   VERCEL_AI_GATEWAY: 'vercel_ai_gateway',
 });
 
+// The primary instrumentor for each provider SDK. Most are third-party
+// traceloop packages, loaded by `package` name. Providers with no usable
+// third-party instrumentor (e.g. ElevenLabs) instead carry a `requirePath` +
+// `className` pointing at the instrumentor weflayr ships itself; `package` then
+// names the provider SDK to suggest installing if its import fails.
 const REGISTRY = {
-  [AiSdk.OPENAI]: '@traceloop/instrumentation-openai',
-  [AiSdk.ANTHROPIC]: '@traceloop/instrumentation-anthropic',
-  [AiSdk.BEDROCK]: '@traceloop/instrumentation-bedrock',
-  [AiSdk.AZURE]: '@traceloop/instrumentation-azure',
-  [AiSdk.COHERE]: '@traceloop/instrumentation-cohere',
-  [AiSdk.TOGETHER]: '@traceloop/instrumentation-together',
-  [AiSdk.GOOGLE_VERTEX]: '@traceloop/instrumentation-vertexai',
-  [AiSdk.GOOGLE_GENAI]: '@traceloop/instrumentation-google-generativeai',
-  [AiSdk.ELEVENLABS]: '@elevenlabs/elevenlabs-js',
+  [AiSdk.OPENAI]: { package: '@traceloop/instrumentation-openai' },
+  [AiSdk.ANTHROPIC]: { package: '@traceloop/instrumentation-anthropic' },
+  [AiSdk.BEDROCK]: { package: '@traceloop/instrumentation-bedrock' },
+  [AiSdk.COHERE]: { package: '@traceloop/instrumentation-cohere' },
+  [AiSdk.GOOGLE_GENAI]: { package: '@traceloop/instrumentation-google-generativeai' },
+  [AiSdk.ELEVENLABS]: {
+    package: '@elevenlabs/elevenlabs-js',
+    requirePath: './instrumentation/elevenlabs/full_instrumentation',
+    className: 'ElevenLabsInstrumentor',
+  },
+};
+
+// One complementary instrumentor per provider: a `set_telemetry_attributes`
+// orchestrator under `instrumentation/<provider>/` that wires every weflayr patch
+// the traceloop instrumentor misses (the orchestrator itself groups the per-patch
+// `get_*` files, so a single entry per provider suffices).
+const COMPLEMENTARY_INSTRUMENTOR = {
+  [AiSdk.OPENAI]: {
+    requirePath: './instrumentation/openai/set_telemetry_attributes',
+    className: 'OpenAITelemetryInstrumentor',
+  },
+  [AiSdk.ANTHROPIC]: {
+    requirePath: './instrumentation/anthropic/set_telemetry_attributes',
+    className: 'AnthropicTelemetryInstrumentor',
+  },
+  [AiSdk.BEDROCK]: {
+    requirePath: './instrumentation/bedrock/set_telemetry_attributes',
+    className: 'BedrockTelemetryInstrumentor',
+  },
+  [AiSdk.COHERE]: {
+    requirePath: './instrumentation/cohere/set_telemetry_attributes',
+    className: 'CohereTelemetryInstrumentor',
+  },
+  [AiSdk.GOOGLE_GENAI]: {
+    requirePath: './instrumentation/google/set_telemetry_attributes',
+    className: 'GoogleTelemetryInstrumentor',
+  },
 };
 
 const SETUP_OPTION_KEYS = [
@@ -65,34 +95,37 @@ async function _instrumentAiSdk(aiSdk) {
       `weflayr.autoInstrument: unknown provider "${aiSdk}". Known: ${Object.keys(REGISTRY).join(', ')}`
     );
   }
-  const pkg = REGISTRY[aiSdk];
-
-  if (aiSdk === AiSdk.ELEVENLABS) {
-    // ElevenLabs has no OTel/traceloop instrumentor, so
-    // use the hand-written one bundled with weflayr.
-    const { ElevenLabsInstrumentor } = require('./instrumentation/elevenlabs');
-    new ElevenLabsInstrumentor().instrument();
-    debug('autoInstrument: registered aiSdk=%s package=%s', aiSdk, pkg);
+  const entry = REGISTRY[aiSdk];
+
+  if (entry.requirePath) {
+    // No usable third-party instrumentor — use the hand-written one bundled
+    // with weflayr (it covers every endpoint of the provider).
+    const Instrumentor = require(entry.requirePath)[entry.className];
+    new Instrumentor().instrument();
+    debug('autoInstrument: registered aiSdk=%s package=%s', aiSdk, entry.package);
     return;
   }
 
   let instrumentationPkg;
   try {
-    instrumentationPkg = require(pkg);
+    instrumentationPkg = require(entry.package);
   } catch (err) {
     throw new Error(
-      `weflayr.autoInstrument("${aiSdk}"): failed to load "${pkg}". ` +
-        `Install it with: npm install ${pkg}\nUnderlying error: ${err.message}`
+      `weflayr.autoInstrument("${aiSdk}"): failed to load "${entry.package}". ` +
+        `Install it with: npm install ${entry.package}\nUnderlying error: ${err.message}`
     );
   }
 
   const instrumentation = _instantiateInstrumentation(instrumentationPkg);
-  if (aiSdk === AiSdk.OPENAI) {
-    // The OpenAI instrumentor drops token usage on streamed calls; backfill it.
-    patchOpenAIStreamingUsage(instrumentation);
-  }
   registerInstrumentations({ instrumentations: [instrumentation] });
-  debug('autoInstrument: registered aiSdk=%s package=%s', aiSdk, pkg);
+
+  const complementary = COMPLEMENTARY_INSTRUMENTOR[aiSdk];
+  if (complementary) {
+    const InstrumentorClass = require(complementary.requirePath)[complementary.className];
+    new InstrumentorClass().instrument(instrumentation);
+  }
+
+  debug('autoInstrument: registered aiSdk=%s package=%s', aiSdk, entry.package);
 }
 
 /**

package/src/instrumentation/anthropic/get_cache_and_reasoning_telemetry.js

@@ -0,0 +1,107 @@
+'use strict';
+
+/**
+ * Cached-prompt token enrichment complement for the non-streamed Anthropic path.
+ *
+ * `@traceloop/instrumentation-anthropic` reads the response's
+ * `usage.cache_creation_input_tokens` / `cache_read_input_tokens` but never writes
+ * them to a `gen_ai.usage.cache_*` span attribute (its semantic conventions define
+ * no such key), so cache-hit spans carry no cached-token counts. This stamps the
+ * underscored attributes the worker reads. (The Python instrumentor emits them
+ * natively, under the dotted `cache_read.input_tokens` form, which the worker also
+ * accepts.)
+ *
+ * It wraps the instrumentor instance's `_endSpan({ span, type, result })`, which
+ * finalizes the span after the response resolves, letting us read `result.usage`
+ * while the span is still open.
+ */
+
+const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
+const CACHE_CREATION_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_creation_input_tokens';
+const INPUT_TOKENS_ATTR = 'gen_ai.usage.input_tokens';
+const THINKING_TOKENS_ATTR = 'gen_ai.usage.output_tokens_details.thinking_tokens';
+
+// Stamp cache counts (and the raw uncached input) from an Anthropic usage object.
+// The instrumentor emits no `gen_ai.usage.cache_*` attribute; `input_tokens` in
+// the stream events is the raw uncached count (cached tokens are reported
+// separately), so it matches the non-streamed override. The extended-thinking
+// count (`output_tokens_details.thinking_tokens`, a subset of output_tokens) is
+// likewise dropped by the instrumentor, so stamp it for the normalizer.
+function _setUsage(span, usage) {
+  if (!usage || !span || !span.isRecording || !span.isRecording()) return;
+  if (usage.cache_read_input_tokens) {
+    span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, usage.cache_read_input_tokens);
+  }
+  if (usage.cache_creation_input_tokens) {
+    span.setAttribute(CACHE_CREATION_INPUT_TOKENS_ATTR, usage.cache_creation_input_tokens);
+  }
+  if (typeof usage.input_tokens === 'number') {
+    span.setAttribute(INPUT_TOKENS_ATTR, usage.input_tokens);
+  }
+  const thinking = usage.output_tokens_details && usage.output_tokens_details.thinking_tokens;
+  if (thinking) {
+    span.setAttribute(THINKING_TOKENS_ATTR, thinking);
+  }
+}
+
+class AnthropicPromptCachingInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is missing cached-token counts, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+
+    // Non-streamed: the instrumentor finalizes via `_endSpan({ span, result })`.
+    const endSpanOriginal = instrumentation._endSpan;
+    if (typeof endSpanOriginal === 'function') {
+      instrumentation._endSpan = function endSpanWithCache(args) {
+        try {
+          _setUsage(args && args.span, args && args.result && args.result.usage);
+        } catch {
+          // Never break span finalization over an enrichment failure.
+        }
+        return endSpanOriginal.call(this, args);
+      };
+      this._patched.push([instrumentation, '_endSpan', endSpanOriginal]);
+    }
+
+    // Streamed: cache + raw input arrive in the `message_start` (and `message_delta`)
+    // usage events; observe the chunks as they pass through the streaming handler.
+    const streamOriginal = instrumentation._streamingWrapPromise;
+    if (typeof streamOriginal === 'function') {
+      instrumentation._streamingWrapPromise = function streamWithCache(...streamArgs) {
+        const opts = streamArgs[streamArgs.length - 1];
+        const span = opts && opts.span;
+        const result = streamOriginal.apply(this, streamArgs);
+        if (!span || !result || typeof result[Symbol.asyncIterator] !== 'function') return result;
+        return (async function* observeCache() {
+          for await (const chunk of result) {
+            try {
+              const usage =
+                (chunk && chunk.type === 'message_start' && chunk.message && chunk.message.usage) ||
+                (chunk && chunk.usage);
+              _setUsage(span, usage);
+            } catch {
+              // Never break the caller's stream over an enrichment failure.
+            }
+            yield chunk;
+          }
+        })();
+      };
+      this._patched.push([instrumentation, '_streamingWrapPromise', streamOriginal]);
+    }
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { AnthropicPromptCachingInstrumentor };

package/src/instrumentation/anthropic/get_streaming_stop_reason_telemetry.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * Streamed stop-reason enrichment for the Anthropic chat span.
+ *
+ * `@traceloop/instrumentation-anthropic` accumulates a streamed response into a
+ * result object but never reads the `message_delta` chunk's `delta.stop_reason`,
+ * so streamed spans format their output message with an empty `finish_reason`.
+ *
+ * `_streamingWrapPromise(client, moduleExports, { span, type, promise })`
+ * returns `new moduleExports.APIPromise(...)` whose parse step wraps the real
+ * SDK stream with the instrumentor's accumulating iterator. This complement
+ * hands it a patched `moduleExports` whose APIPromise interposes on that parse
+ * step, observing the chunks (outside the accumulating iterator, so every chunk
+ * is seen before the iterator finishes) to capture the stop reason — which is
+ * then injected into the accumulated result just before `_endSpan` formats the
+ * output message.
+ */
+
+class AnthropicStreamingStopReasonInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+    // span -> stop_reason captured from the stream's message_delta chunk.
+    this._stopReasonBySpan = new WeakMap();
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is an empty streamed finish_reason, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+
+    const stopReasonBySpan = this._stopReasonBySpan;
+
+    async function* observeStopReason(stream, span) {
+      for await (const chunk of stream) {
+        try {
+          if (
+            chunk &&
+            chunk.type === 'message_delta' &&
+            chunk.delta &&
+            chunk.delta.stop_reason != null
+          ) {
+            stopReasonBySpan.set(span, chunk.delta.stop_reason);
+          }
+        } catch {
+          // Never break the caller's stream over an enrichment failure.
+        }
+        yield chunk;
+      }
+    }
+
+    const streamOriginal = instrumentation._streamingWrapPromise;
+    if (typeof streamOriginal === 'function') {
+      instrumentation._streamingWrapPromise = function streamWithStopReason(
+        client,
+        moduleExports,
+        opts
+      ) {
+        const span = opts && opts.span;
+        if (!span || !moduleExports || typeof moduleExports.APIPromise !== 'function') {
+          return streamOriginal.call(this, client, moduleExports, opts);
+        }
+        class APIPromiseWithStopReason extends moduleExports.APIPromise {
+          constructor(promiseClient, responsePromise, parseResponse) {
+            super(promiseClient, responsePromise, async (parseClient, props) => {
+              const stream = await parseResponse(parseClient, props);
+              try {
+                if (
+                  stream &&
+                  typeof stream[Symbol.asyncIterator] === 'function' &&
+                  typeof stream.constructor === 'function'
+                ) {
+                  return new stream.constructor(
+                    () => observeStopReason(stream, span),
+                    stream.controller
+                  );
+                }
+              } catch {
+                // Fall through to the unobserved stream.
+              }
+              return stream;
+            });
+          }
+        }
+        // The SDK's module exports are non-writable, so the override is an own
+        // defined property shadowing the inherited one.
+        const patchedModuleExports = Object.create(moduleExports, {
+          APIPromise: { value: APIPromiseWithStopReason, configurable: true },
+        });
+        return streamOriginal.call(this, client, patchedModuleExports, opts);
+      };
+      this._patched.push([instrumentation, '_streamingWrapPromise', streamOriginal]);
+    }
+
+    const endSpanOriginal = instrumentation._endSpan;
+    if (typeof endSpanOriginal === 'function') {
+      instrumentation._endSpan = function endSpanWithStopReason(args) {
+        try {
+          const captured = args && args.span && stopReasonBySpan.get(args.span);
+          if (captured != null && args.result && args.result.stop_reason == null) {
+            args.result.stop_reason = captured;
+          }
+        } catch {
+          // Never break span finalization over an enrichment failure.
+        }
+        return endSpanOriginal.call(this, args);
+      };
+      this._patched.push([instrumentation, '_endSpan', endSpanOriginal]);
+    }
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { AnthropicStreamingStopReasonInstrumentor };

package/src/instrumentation/anthropic/get_tool_definitions_telemetry.js

@@ -0,0 +1,50 @@
+'use strict';
+
+/**
+ * Tool-definitions enrichment for the Anthropic chat span.
+ *
+ * `@traceloop/instrumentation-anthropic` records the request model/temperature
+ * attributes in `startSpan({ type, params })` but never the request's `tools`,
+ * so tool-using calls carry no `gen_ai.tool.definitions`. Wrap `startSpan` to
+ * stamp them in the same `{name, description, input_schema}` shape the request
+ * uses. The span processor strips the attribute when message-content capture is
+ * disabled.
+ */
+
+class AnthropicToolDefinitionsInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is missing tool definitions, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+    const startSpanOriginal = instrumentation.startSpan;
+    if (typeof startSpanOriginal !== 'function') return;
+
+    instrumentation.startSpan = function startSpanWithToolDefinitions(request) {
+      const span = startSpanOriginal.call(this, request);
+      try {
+        const tools = request && request.params && request.params.tools;
+        if (Array.isArray(tools) && tools.length) {
+          span.setAttribute('gen_ai.tool.definitions', JSON.stringify(tools));
+        }
+      } catch {
+        // Never break span creation over an enrichment failure.
+      }
+      return span;
+    };
+    this._patched.push([instrumentation, 'startSpan', startSpanOriginal]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { AnthropicToolDefinitionsInstrumentor };

package/src/instrumentation/anthropic/set_telemetry_attributes.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Anthropic telemetry complement — the registered orchestrator.
+ *
+ * Wires the weflayr-supplied patches the traceloop Anthropic instrumentor
+ * misses: cached-prompt token counts on the chat span (it reads them off the
+ * response but writes no `gen_ai.usage.cache_*` attribute), the request's tool
+ * definitions, and the streamed stop reason (its stream accumulator drops it,
+ * leaving an empty finish_reason on the output message).
+ */
+
+const { AnthropicPromptCachingInstrumentor } = require('./get_cache_and_reasoning_telemetry');
+const {
+  AnthropicStreamingStopReasonInstrumentor,
+} = require('./get_streaming_stop_reason_telemetry');
+const { AnthropicToolDefinitionsInstrumentor } = require('./get_tool_definitions_telemetry');
+
+class AnthropicTelemetryInstrumentor {
+  constructor() {
+    this._subInstrumentors = [
+      new AnthropicPromptCachingInstrumentor(),
+      new AnthropicStreamingStopReasonInstrumentor(),
+      new AnthropicToolDefinitionsInstrumentor(),
+    ];
+  }
+
+  instrument(instrumentation) {
+    for (const sub of this._subInstrumentors) sub.instrument(instrumentation);
+  }
+
+  uninstrument() {
+    for (const sub of this._subInstrumentors) sub.uninstrument();
+  }
+}
+
+module.exports = { AnthropicTelemetryInstrumentor };

package/src/instrumentation/bedrock/get_cache_telemetry.js

@@ -0,0 +1,104 @@
+'use strict';
+
+/**
+ * Cached-prompt token enrichment complement for the Bedrock invoke_model path.
+ *
+ * `@traceloop/instrumentation-bedrock` records `gen_ai.usage.{input,output}_tokens`
+ * off the InvokeModel response body but never reads its cache-token counts, so
+ * spans for prompt-cache hits carry no cached-token figures. Amazon Nova's native
+ * InvokeModel response includes `usage.cacheReadInputTokenCount` /
+ * `usage.cacheWriteInputTokenCount`; this maps them to the
+ * `gen_ai.usage.cache_read_input_tokens` / `cache_creation_input_tokens`
+ * attributes the worker reads, matching the Python SDK.
+ *
+ * It wraps the instrumentor instance's `_wrapPromise(span, promise, modelId)`,
+ * which resolves the send promise and enriches the span before ending it,
+ * letting us read the decoded body off the same response while the span is open.
+ */
+
+const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
+const CACHE_CREATION_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_creation_input_tokens';
+
+// Stamp cache counts from a Nova `usage` object onto the span.
+function _setCacheFromUsage(span, usage) {
+  if (!usage || !span || !span.isRecording || !span.isRecording()) return;
+  if (typeof usage.cacheReadInputTokenCount === 'number' && usage.cacheReadInputTokenCount) {
+    span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, usage.cacheReadInputTokenCount);
+  }
+  if (typeof usage.cacheWriteInputTokenCount === 'number' && usage.cacheWriteInputTokenCount) {
+    span.setAttribute(CACHE_CREATION_INPUT_TOKENS_ATTR, usage.cacheWriteInputTokenCount);
+  }
+}
+
+function _setCacheTokens(span, response) {
+  if (!span || !span.isRecording || !span.isRecording()) return;
+  const body = response && response.body;
+  // Only the non-streaming InvokeModel response buffers its body as bytes; a
+  // response stream is an async iterable whose usage arrives in a trailing chunk
+  // handled by the streaming wrap below, so skip it here (and never consume the
+  // caller's stream).
+  if (!body || typeof body[Symbol.asyncIterator] === 'function') return;
+  try {
+    _setCacheFromUsage(span, JSON.parse(new TextDecoder().decode(body)).usage);
+  } catch {
+    // Never break span enrichment over a parse failure.
+  }
+}
+
+class BedrockPromptCachingInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is missing cached-token counts, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+
+    // Non-streamed: enrich the buffered InvokeModel response body.
+    const wrapPromiseOriginal = instrumentation._wrapPromise;
+    if (typeof wrapPromiseOriginal === 'function') {
+      instrumentation._wrapPromise = function wrapPromiseWithCache(span, promise, modelId) {
+        // Stamp cache tokens off the response, then hand the same response to the
+        // original handler (which decodes the still-buffered body for input/output
+        // tokens). Resolving to the original response keeps behaviour identical.
+        const enriched = Promise.resolve(promise).then((response) => {
+          _setCacheTokens(span, response);
+          return response;
+        });
+        return wrapPromiseOriginal.call(this, span, enriched, modelId);
+      };
+      this._patched.push([instrumentation, '_wrapPromise', wrapPromiseOriginal]);
+    }
+
+    // Streamed: the instrumentor processes the trailing metadata chunk via
+    // `_handleNovaStreamingMetadata(span, parsedResponse)` (reading
+    // `parsedResponse.metadata.usage` for input/output) but never its cache counts.
+    const metadataOriginal = instrumentation._handleNovaStreamingMetadata;
+    if (typeof metadataOriginal === 'function') {
+      instrumentation._handleNovaStreamingMetadata = function handleMetadataWithCache(
+        span,
+        parsedResponse
+      ) {
+        try {
+          const usage = parsedResponse && parsedResponse.metadata && parsedResponse.metadata.usage;
+          _setCacheFromUsage(span, usage);
+        } catch {
+          // Never break the caller's stream over an enrichment failure.
+        }
+        return metadataOriginal.call(this, span, parsedResponse);
+      };
+      this._patched.push([instrumentation, '_handleNovaStreamingMetadata', metadataOriginal]);
+    }
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { BedrockPromptCachingInstrumentor };