weflayr 0.24.0 → 0.26.0

package/src/instrumentation/bedrock/get_cache_config_telemetry.js

@@ -1,106 +0,0 @@
-'use strict';
-
-/**
- * Request-side prompt-caching config capture for Bedrock invoke_model spans.
- *
- * Bedrock callers opt into caching in the request body, in the model vendor's
- * own schema: Anthropic-on-Bedrock bodies carry `cache_control` blocks (the
- * native Anthropic shape), Amazon Nova bodies carry `cachePoint` blocks (the
- * Converse shape) — on system entries, message content blocks or tool
- * definitions, each with an optional raw `ttl` string ("5m"/"1h"). The
- * traceloop instrumentor never records them.
- *
- * Wrap the instrumentor's `_startSpan({ params })` (params.body is the raw
- * request JSON) to stamp every breakpoint found as `weflayr.cache.breakpoints`.
- * Bedrock responses report no TTL split of the written tokens; the worker
- * derives it from these breakpoints when they all share one TTL.
- */
-
-const { extractCacheBreakpoints } = require('../anthropic/get_cache_config_telemetry');
-
-const BREAKPOINTS_ATTR = 'weflayr.cache.breakpoints';
-
-// A breakpoint as location + the raw `cachePoint` `ttl` string, omitted when
-// the request sets none.
-function _cachePointEntry(location, cachePoint) {
-  const ttl = cachePoint && cachePoint.ttl;
-  return ttl ? { location, ttl: String(ttl) } : { location };
-}
-
-// The first `cachePoint` among a list of blocks (attached to a content block,
-// or standing alone as its own block), or undefined.
-function _cachePointOfBlocks(blocks) {
-  if (!Array.isArray(blocks)) return undefined;
-  const block = blocks.find((entry) => entry && entry.cachePoint != null);
-  return block && block.cachePoint;
-}
-
-// Every cache breakpoint in an InvokeModel request body, as location + the
-// raw `ttl` string (omitted when the breakpoint sets none): the
-// Anthropic-on-Bedrock `cache_control` shape and the Nova `cachePoint` shape
-// (which never overlap in one body).
-function extractBedrockCacheBreakpoints(body) {
-  const breakpoints = extractCacheBreakpoints(body);
-  const systemCachePoint = _cachePointOfBlocks(body.system);
-  if (systemCachePoint != null) {
-    breakpoints.push(_cachePointEntry('system', systemCachePoint));
-  }
-  (body.messages || []).forEach((message, index) => {
-    const cachePoint = _cachePointOfBlocks(message && message.content);
-    if (cachePoint != null) {
-      breakpoints.push(_cachePointEntry(`messages[${index}]`, cachePoint));
-    }
-  });
-  const tools = (body.toolConfig && body.toolConfig.tools) || [];
-  tools.forEach((tool, index) => {
-    if (tool && tool.cachePoint != null) {
-      breakpoints.push(_cachePointEntry(`tools[${index}]`, tool.cachePoint));
-    }
-  });
-  return breakpoints;
-}
-
-class BedrockCacheConfigInstrumentor {
-  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 cache-config capture, never a crash.
-  instrument(instrumentation) {
-    if (!instrumentation) return;
-    const startSpanOriginal = instrumentation._startSpan;
-    if (typeof startSpanOriginal !== 'function') return;
-
-    instrumentation._startSpan = function startSpanWithCacheConfig(request) {
-      const span = startSpanOriginal.call(this, request);
-      try {
-        const rawBody =
-          request && request.params && request.params.input && request.params.input.body;
-        if (typeof rawBody === 'string' || rawBody instanceof Uint8Array) {
-          const body = JSON.parse(
-            typeof rawBody === 'string' ? rawBody : new TextDecoder().decode(rawBody)
-          );
-          const breakpoints = extractBedrockCacheBreakpoints(body || {});
-          if (breakpoints.length) {
-            span.setAttribute(BREAKPOINTS_ATTR, JSON.stringify(breakpoints));
-          }
-        }
-      } 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 = { BedrockCacheConfigInstrumentor, extractBedrockCacheBreakpoints };

package/src/instrumentation/bedrock/get_cache_telemetry.js

@@ -1,109 +0,0 @@
-'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` (Anthropic-on-Bedrock responses carry the
- * native `usage.cache_read_input_tokens` / `cache_creation_input_tokens`);
- * 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 `usage` object onto the span: Nova's camelCase
-// count fields, or Anthropic-on-Bedrock's native snake_case ones.
-function _setCacheFromUsage(span, usage) {
-  if (!usage || !span || !span.isRecording || !span.isRecording()) return;
-  const read = usage.cacheReadInputTokenCount ?? usage.cache_read_input_tokens;
-  const write = usage.cacheWriteInputTokenCount ?? usage.cache_creation_input_tokens;
-  if (typeof read === 'number' && read) {
-    span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, read);
-  }
-  if (typeof write === 'number' && write) {
-    span.setAttribute(CACHE_CREATION_INPUT_TOKENS_ATTR, write);
-  }
-}
-
-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/get_input_message_content_telemetry.js

@@ -1,94 +0,0 @@
-'use strict';
-
-/**
- * Input message content for Bedrock invoke_model spans the instrumentor misses.
- *
- * `@traceloop/instrumentation-bedrock` parses the request body per model vendor,
- * so a call whose model id has no recognizable vendor (e.g. an invalid model —
- * exactly the error spans) gets no `gen_ai.input.messages`. Wrap the
- * instrumentor's `_startSpan({ params })` to stamp the input messages from the
- * request body whenever the instrumentor did not. The span processor strips the
- * attribute when message-content capture is disabled.
- */
-
-function _contentToParts(content) {
-  if (typeof content === 'string') {
-    return [{ type: 'text', content }];
-  }
-  if (Array.isArray(content)) {
-    return content
-      .filter((block) => block && typeof block.text === 'string')
-      .map((block) => ({ type: 'text', content: block.text }));
-  }
-  return [];
-}
-
-// Messages in the role+parts shape from an InvokeModel JSON body — the
-// `messages` schema (Nova, Anthropic-on-Bedrock) or the flat `inputText` /
-// `prompt` schemas (Titan, legacy).
-function _inputMessagesFromRequestBody(rawBody) {
-  if (typeof rawBody !== 'string') return [];
-  let body;
-  try {
-    body = JSON.parse(rawBody);
-  } catch {
-    return [];
-  }
-  if (!body || typeof body !== 'object') return [];
-  if (Array.isArray(body.messages)) {
-    return body.messages
-      .filter((message) => message && typeof message === 'object')
-      .map((message) => ({
-        role: String(message.role || ''),
-        parts: _contentToParts(message.content),
-      }));
-  }
-  const prompt = body.inputText || body.prompt;
-  if (typeof prompt === 'string') {
-    return [{ role: 'user', parts: [{ type: 'text', content: prompt }] }];
-  }
-  return [];
-}
-
-class BedrockInputMessageContentInstrumentor {
-  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 input messages, never a crash.
-  instrument(instrumentation) {
-    if (!instrumentation) return;
-    const original = instrumentation._startSpan;
-    if (typeof original !== 'function') return;
-
-    instrumentation._startSpan = function startSpanWithInputMessages(request) {
-      const span = original.call(this, request);
-      try {
-        const attributes = span && span.attributes;
-        if (attributes && attributes['gen_ai.input.messages'] == null) {
-          const body =
-            request && request.params && request.params.input && request.params.input.body;
-          const messages = _inputMessagesFromRequestBody(body);
-          if (messages.length) {
-            span.setAttribute('gen_ai.input.messages', JSON.stringify(messages));
-          }
-        }
-      } catch {
-        // Never break span creation over an enrichment failure.
-      }
-      return span;
-    };
-    this._patched.push([instrumentation, '_startSpan', original]);
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-}
-
-module.exports = { BedrockInputMessageContentInstrumentor };

package/src/instrumentation/bedrock/get_streaming_output_message_telemetry.js

@@ -1,87 +0,0 @@
-'use strict';
-
-/**
- * Streamed-output message content for the Bedrock invoke_model stream span.
- *
- * `@traceloop/instrumentation-bedrock` accumulates the streamed text but formats
- * the final `gen_ai.output.messages` by passing that string through its chat
- * block mapper, which only accepts block arrays — so streamed Nova spans end up
- * with an assistant message whose `parts` is empty. This complement wraps the
- * instrumentor's per-chunk `_handleNovaStreamingMetadata(span, parsedResponse)`
- * hook: it accumulates the `contentBlockDelta` text and the `messageStop` stop
- * reason itself, and re-stamps a correct output message when the trailing
- * `metadata` chunk (always last in a Nova stream) arrives — after the
- * instrumentor has written its empty-parts message. The span processor strips
- * the attribute when message-content capture is disabled.
- */
-
-// Nova stop reasons mapped to the OTel finish_reason values the instrumentor
-// uses on non-streamed spans, so streamed and non-streamed rows normalize alike.
-const FINISH_REASON_BY_STOP_REASON = {
-  end_turn: 'stop',
-  stop_sequence: 'stop',
-  max_tokens: 'length',
-  tool_use: 'tool_call',
-};
-
-class BedrockStreamingOutputMessageInstrumentor {
-  constructor() {
-    // [instrumentation, methodName, originalFunction] for uninstrument().
-    this._patched = [];
-    // span -> {text, stopReason} accumulated across the stream's chunks.
-    this._streamStateBySpan = new WeakMap();
-  }
-
-  // No-op (and never throws) if the instrumentor's internals have changed shape —
-  // the worst case is an empty streamed output message, never a crash.
-  instrument(instrumentation) {
-    if (!instrumentation) return;
-    const original = instrumentation._handleNovaStreamingMetadata;
-    if (typeof original !== 'function') return;
-
-    const streamStateBySpan = this._streamStateBySpan;
-    instrumentation._handleNovaStreamingMetadata = function handleWithOutputMessage(
-      span,
-      parsedResponse
-    ) {
-      try {
-        const state = streamStateBySpan.get(span) || { text: '', stopReason: null };
-        const delta =
-          parsedResponse &&
-          parsedResponse.contentBlockDelta &&
-          parsedResponse.contentBlockDelta.delta &&
-          parsedResponse.contentBlockDelta.delta.text;
-        if (typeof delta === 'string') state.text += delta;
-        const stopReason =
-          parsedResponse && parsedResponse.messageStop && parsedResponse.messageStop.stopReason;
-        if (stopReason != null) state.stopReason = stopReason;
-        streamStateBySpan.set(span, state);
-
-        if (parsedResponse && parsedResponse.metadata && state.text) {
-          const message = {
-            role: 'assistant',
-            parts: [{ type: 'text', content: state.text }],
-          };
-          if (state.stopReason != null) {
-            message.finish_reason =
-              FINISH_REASON_BY_STOP_REASON[state.stopReason] || state.stopReason;
-          }
-          span.setAttribute('gen_ai.output.messages', JSON.stringify([message]));
-        }
-      } catch {
-        // Never break the caller's stream over an enrichment failure.
-      }
-      return original.call(this, span, parsedResponse);
-    };
-    this._patched.push([instrumentation, '_handleNovaStreamingMetadata', original]);
-  }
-
-  uninstrument() {
-    for (const [owner, methodName, original] of this._patched) {
-      owner[methodName] = original;
-    }
-    this._patched = [];
-  }
-}
-
-module.exports = { BedrockStreamingOutputMessageInstrumentor };

package/src/instrumentation/bedrock/set_telemetry_attributes.js

@@ -1,40 +0,0 @@
-'use strict';
-
-/**
- * Bedrock telemetry complement — the registered orchestrator.
- *
- * Wires the weflayr-supplied patches 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), the request's cache
- * breakpoints (`cache_control` / `cachePoint` blocks it never records) and the
- * streamed output message content (its stream path formats an empty-parts
- * message).
- */
-
-const { BedrockCacheConfigInstrumentor } = require('./get_cache_config_telemetry');
-const { BedrockPromptCachingInstrumentor } = require('./get_cache_telemetry');
-const { BedrockInputMessageContentInstrumentor } = require('./get_input_message_content_telemetry');
-const {
-  BedrockStreamingOutputMessageInstrumentor,
-} = require('./get_streaming_output_message_telemetry');
-
-class BedrockTelemetryInstrumentor {
-  constructor() {
-    this._subInstrumentors = [
-      new BedrockPromptCachingInstrumentor(),
-      new BedrockCacheConfigInstrumentor(),
-      new BedrockInputMessageContentInstrumentor(),
-      new BedrockStreamingOutputMessageInstrumentor(),
-    ];
-  }
-
-  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

@@ -1,88 +0,0 @@
-'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

@@ -1,107 +0,0 @@
-'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);
-    }
-    // The embedded texts are the prompt; stamp one user message per text, like
-    // the chat path. The span processor strips it when content capture is off.
-    if (request && Array.isArray(request.texts) && request.texts.length) {
-      span.setAttribute(
-        'gen_ai.input.messages',
-        JSON.stringify(
-          request.texts.map((text) => ({ role: 'user', parts: [{ type: 'text', content: text }] }))
-        )
-      );
-    }
-    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

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