weflayr 0.20.5 → 0.21.0

package/index.d.ts

@@ -38,6 +38,7 @@ export const AiSdk: {
   readonly TOGETHER: 'together';
   readonly GOOGLE_VERTEX: 'google-vertex';
   readonly GOOGLE_GENAI: 'google-genai';
+  readonly ELEVENLABS: 'elevenlabs';
 };
 export type AiSdk = (typeof AiSdk)[keyof typeof AiSdk];
 
@@ -55,6 +56,7 @@ export const AIProviderName: {
   readonly TOGETHER: 'together';
   readonly GOOGLE_VERTEX: 'google-vertex';
   readonly GOOGLE_GENAI: 'google-genai';
+  readonly ELEVENLABS: 'elevenlabs';
   readonly VERCEL_AI_GATEWAY: 'vercel_ai_gateway';
 };
 export type AIProviderName = (typeof AIProviderName)[keyof typeof AIProviderName];

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "weflayr",
-  "version": "0.20.5",
+  "version": "0.21.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",
+    "test": "node --test",
     "lint": "eslint src tests",
     "lint:fix": "eslint src tests --fix",
     "format": "prettier --write src tests",

package/src/auto-instrument.js

@@ -4,37 +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.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 = [
@@ -63,25 +95,37 @@ async function _instrumentAiSdk(aiSdk) {
       `weflayr.autoInstrument: unknown provider "${aiSdk}". Known: ${Object.keys(REGISTRY).join(', ')}`
     );
   }
-  const pkg = REGISTRY[aiSdk];
+  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/set_telemetry_attributes.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * Anthropic telemetry complement — the registered orchestrator.
+ *
+ * Wires the one weflayr-supplied patch 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).
+ */
+
+const { AnthropicPromptCachingInstrumentor } = require('./get_cache_and_reasoning_telemetry');
+
+class AnthropicTelemetryInstrumentor {
+  constructor() {
+    this._subInstrumentors = [new AnthropicPromptCachingInstrumentor()];
+  }
+
+  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 };

package/src/instrumentation/bedrock/set_telemetry_attributes.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * Bedrock telemetry complement — the registered orchestrator.
+ *
+ * Wires the one weflayr-supplied patch the traceloop Bedrock instrumentor misses:
+ * cached-prompt token counts on the invoke_model span (Nova returns them in the
+ * response body but traceloop never reads them).
+ */
+
+const { BedrockPromptCachingInstrumentor } = require('./get_cache_telemetry');
+
+class BedrockTelemetryInstrumentor {
+  constructor() {
+    this._subInstrumentors = [new BedrockPromptCachingInstrumentor()];
+  }
+
+  instrument(instrumentation) {
+    for (const sub of this._subInstrumentors) sub.instrument(instrumentation);
+  }
+
+  uninstrument() {
+    for (const sub of this._subInstrumentors) sub.uninstrument();
+  }
+}
+
+module.exports = { BedrockTelemetryInstrumentor };

package/src/instrumentation/cohere/get_chat_telemetry.js

@@ -0,0 +1,88 @@
+'use strict';
+
+/**
+ * Chat token-usage enrichment complement for the Cohere v1 chat path.
+ *
+ * `@traceloop/instrumentation-cohere` creates the `cohere.chat` span but reads
+ * token usage from the obsolete `result.token_count.{prompt,response}_tokens`
+ * shape; modern cohere-ai returns usage under `meta.billedUnits` instead, so the
+ * traceloop span ends up with zero chat tokens. This thin complement backfills
+ * `gen_ai.usage.{input,output}_tokens` from `meta.billedUnits`, the same source
+ * traceloop already uses for the `generate` endpoint — bringing Node chat tokens
+ * to parity with the Python SDK (OpenLLMetry captures them natively, so there is
+ * no Python counterpart).
+ *
+ * It hooks the internal `CohereClient.prototype.__chat` (which the public `chat`
+ * delegates to synchronously) rather than the public `chat`: traceloop wraps
+ * `chat` and opens the span around it, so `__chat` runs while that span is the
+ * active span — letting this complement enrich it regardless of patch order.
+ */
+
+const { trace } = require('@opentelemetry/api');
+
+function _billedUnits(result) {
+  // Public `chat` resolves to the response body, but `__chat` resolves to the
+  // Fern wrapper `{ data, rawResponse }`; read billedUnits off either shape.
+  const response = result && result.data ? result.data : result;
+  return response && response.meta ? response.meta.billedUnits : undefined;
+}
+
+function _setChatTokenUsage(span, result) {
+  const billedUnits = _billedUnits(result);
+  if (!billedUnits) return;
+  if (typeof billedUnits.inputTokens === 'number') {
+    span.setAttribute('gen_ai.usage.input_tokens', billedUnits.inputTokens);
+  }
+  if (typeof billedUnits.outputTokens === 'number') {
+    span.setAttribute('gen_ai.usage.output_tokens', billedUnits.outputTokens);
+  }
+}
+
+class CohereChatTokenUsageInstrumentor {
+  constructor() {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  instrument() {
+    let CohereClient;
+    try {
+      ({ CohereClient } = require('cohere-ai/Client'));
+    } catch (err) {
+      throw new Error(
+        'weflayr.autoInstrument(COHERE): the cohere-ai client is not installed. ' +
+          'Install it with: npm install cohere-ai\n' +
+          `Underlying error: ${err.message}`
+      );
+    }
+
+    this._wrap(CohereClient.prototype, '__chat');
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+
+  _wrap(owner, methodName) {
+    const original = owner[methodName];
+
+    function wrapper(...args) {
+      // Captured synchronously, while traceloop's chat span is still active.
+      const span = trace.getActiveSpan();
+      const result = original.apply(this, args);
+      if (!span || !span.isRecording || !span.isRecording()) return result;
+      return Promise.resolve(result).then((response) => {
+        _setChatTokenUsage(span, response);
+        return response;
+      });
+    }
+
+    owner[methodName] = wrapper;
+    this._patched.push([owner, methodName, original]);
+  }
+}
+
+module.exports = { CohereChatTokenUsageInstrumentor };

package/src/instrumentation/cohere/get_embeddings_telemetry.js

@@ -0,0 +1,97 @@
+'use strict';
+
+/**
+ * Hand-written OTel instrumentor for the Cohere embeddings endpoint.
+ *
+ * `@traceloop/instrumentation-cohere` (the package weflayr uses for Cohere on
+ * Node) wraps chat/generate/rerank but not `embed`, so this ships inside weflayr
+ * to cover it. OpenLLMetry's cohere instrumentor doesn't cover `embed` either, so
+ * the Python SDK has a mirror complement (`cohere_embeddings.py`) shaped to
+ * normalize identically. It is registered alongside the traceloop instrumentor
+ * whenever `autoInstrument({ aiSdks: 'cohere' })` runs.
+ *
+ * Embeddings are billed per input token, so the span records the input tokens
+ * Cohere returns under `gen_ai.usage.input_tokens`; there is no completion.
+ */
+
+const { trace, SpanStatusCode } = require('@opentelemetry/api');
+
+const TRACER_NAME = 'weflayr.instrumentation.cohere_embeddings';
+// Matches the gen_ai.system the cohere chat instrumentors set (Python + Node).
+const SYSTEM = 'Cohere';
+const EMBEDDINGS_OPERATION = 'embeddings';
+
+function _recordError(span, error) {
+  span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message ?? String(error) });
+  span.recordException(error);
+}
+
+function _wrapEmbed(owner, patched) {
+  const original = owner.embed;
+
+  function wrapper(request, ...rest) {
+    const span = trace.getTracer(TRACER_NAME).startSpan(EMBEDDINGS_OPERATION);
+    span.setAttribute('gen_ai.system', SYSTEM);
+    span.setAttribute('gen_ai.operation.name', EMBEDDINGS_OPERATION);
+    if (request && request.model) {
+      span.setAttribute('gen_ai.request.model', request.model);
+    }
+    return Promise.resolve(original.call(this, request, ...rest)).then(
+      (response) => {
+        // Node SDK reports the billed input tokens under camelCase keys.
+        const inputTokens =
+          response?.meta?.billedUnits?.inputTokens ?? response?.meta?.tokens?.inputTokens;
+        if (inputTokens != null) {
+          span.setAttribute('gen_ai.usage.input_tokens', inputTokens);
+        }
+        span.end();
+        return response;
+      },
+      (error) => {
+        _recordError(span, error);
+        span.end();
+        throw error;
+      }
+    );
+  }
+
+  owner.embed = wrapper;
+  patched.push([owner, 'embed', original]);
+}
+
+class CohereEmbeddingsInstrumentor {
+  constructor() {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  instrument() {
+    let CohereClient;
+    let V2Client;
+    try {
+      // v1 `embed` is a prototype method on CohereClient; v2 `embed` lives on
+      // V2Client.prototype (CohereClientV2 binds it as an instance property, so
+      // it must be patched on the underlying V2Client class instead).
+      ({ CohereClient } = require('cohere-ai/Client'));
+      ({ V2Client } = require('cohere-ai/api/resources/v2/client/Client'));
+    } catch (err) {
+      throw new Error(
+        'weflayr.autoInstrument(COHERE): the cohere-ai client is not installed. ' +
+          'Install it with: npm install cohere-ai\n' +
+          `Underlying error: ${err.message}`
+      );
+    }
+
+    _wrapEmbed(CohereClient.prototype, this._patched);
+    _wrapEmbed(V2Client.prototype, this._patched);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { CohereEmbeddingsInstrumentor };

package/src/instrumentation/cohere/set_telemetry_attributes.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * Cohere telemetry complement — the registered orchestrator.
+ *
+ * Wires the weflayr-supplied patches the traceloop Cohere instrumentor misses:
+ *   - chat token usage (traceloop reads the obsolete usage shape and records
+ *     zero chat tokens), and
+ *   - the embeddings endpoint it doesn't cover.
+ */
+
+const { CohereChatTokenUsageInstrumentor } = require('./get_chat_telemetry');
+const { CohereEmbeddingsInstrumentor } = require('./get_embeddings_telemetry');
+
+class CohereTelemetryInstrumentor {
+  constructor() {
+    this._subInstrumentors = [
+      new CohereChatTokenUsageInstrumentor(),
+      new CohereEmbeddingsInstrumentor(),
+    ];
+  }
+
+  instrument(instrumentation) {
+    for (const sub of this._subInstrumentors) sub.instrument(instrumentation);
+  }
+
+  uninstrument() {
+    for (const sub of this._subInstrumentors) sub.uninstrument();
+  }
+}
+
+module.exports = { CohereTelemetryInstrumentor };