weflayr 0.24.0 → 0.26.1

package/src/auto-instrument.js

@@ -1,172 +0,0 @@
-'use strict';
-
-const { registerInstrumentations } = require('@opentelemetry/instrumentation');
-
-const { debug } = require('./logger');
-const { setup, _state } = require('./setup');
-
-const AiSdk = Object.freeze({
-  OPENAI: 'openai',
-  ANTHROPIC: 'anthropic',
-  BEDROCK: 'bedrock',
-  COHERE: 'cohere',
-  GOOGLE_GENAI: 'google-genai',
-  ELEVENLABS: 'elevenlabs',
-  VERCEL_AI_GATEWAY: 'vercel_ai_gateway',
-});
-
-// Allowed values for `propagateMetadata({ providerName })`: the actual AI
-// providers a call can be attributed to. Unlike AiSdk this names providers,
-// not SDKs — google-genai is an SDK whose calls are labelled gemini or vertex,
-// and mistral has no Node OTel instrumentor so it is reached through the
-// OpenAI SDK (OpenAI-compatible endpoint) but reported as itself.
-const AIProviderName = Object.freeze({
-  OPENAI: 'openai',
-  AZURE_OPENAI: 'azure',
-  ANTHROPIC: 'anthropic',
-  BEDROCK: 'bedrock',
-  COHERE: 'cohere',
-  ELEVENLABS: 'elevenlabs',
-  MISTRAL: 'mistral',
-  VERCEL_AI_GATEWAY: 'vercel_ai_gateway',
-  GEMINI: 'gemini',
-  VERTEX: 'vertex',
-});
-
-// 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]: { 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',
-  },
-  [AiSdk.VERCEL_AI_GATEWAY]: {
-    package: 'ai',
-    requirePath: './instrumentation/vercel/full_instrumentation',
-    className: 'VercelAiSdkInstrumentor',
-  },
-};
-
-// 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 = [
-  'apiKey',
-  'baseUrl',
-  'defaultTags',
-  'exportMode',
-  'mask',
-  'captureMessageContent',
-  'warnOnExportError',
-];
-
-function _instantiateInstrumentation(instrumentationPkg) {
-  for (const value of Object.values(instrumentationPkg)) {
-    if (typeof value === 'function' && /Instrumentation$/.test(value.name)) {
-      return new value();
-    }
-  }
-  if (typeof instrumentationPkg.default === 'function') return new instrumentationPkg.default();
-  throw new Error('No Instrumentation class found in module exports');
-}
-
-async function _instrumentAiSdk(aiSdk) {
-  if (!(aiSdk in REGISTRY)) {
-    throw new Error(
-      `weflayr.autoInstrument: unknown provider "${aiSdk}". Known: ${Object.keys(REGISTRY).join(', ')}`
-    );
-  }
-  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(entry.package);
-  } catch (err) {
-    throw new Error(
-      `weflayr.autoInstrument("${aiSdk}"): failed to load "${entry.package}". ` +
-        `Install it with: npm install ${entry.package}\nUnderlying error: ${err.message}`
-    );
-  }
-
-  const instrumentation = _instantiateInstrumentation(instrumentationPkg);
-  registerInstrumentations({ instrumentations: [instrumentation] });
-
-  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);
-}
-
-/**
- * Register an OTel Instrumentor for one or more LLM provider SDKs.
- *
- * Convenience: pass `apiKey` (+ other `setup()` options) here to skip a
- * separate `weflayr.setup()` call. If `apiKey` is omitted, `setup()` must
- * have been called beforehand.
- */
-async function autoInstrument({ aiSdks, ...options } = {}) {
-  if (aiSdks === undefined) {
-    throw new Error('weflayr.autoInstrument: `aiSdks` is required.');
-  }
-
-  if (!_state.processor) {
-    // setup() picks up WEFLAYR_API_KEY from the env if not passed here.
-    const setupOptions = {};
-    for (const key of SETUP_OPTION_KEYS) {
-      if (options[key] !== undefined) setupOptions[key] = options[key];
-    }
-    setup(setupOptions);
-  }
-
-  const list = Array.isArray(aiSdks) ? aiSdks : [aiSdks];
-  for (const aiSdk of list) {
-    await _instrumentAiSdk(aiSdk);
-  }
-}
-
-module.exports = { autoInstrument, AiSdk, AIProviderName, REGISTRY };

package/src/index.js

@@ -1,19 +0,0 @@
-'use strict';
-
-const { setup, flush } = require('./setup');
-const { autoInstrument, AiSdk, AIProviderName } = require('./auto-instrument');
-const { propagateMetadata } = require('./otel/propagation');
-// Public-API client (revenue, key metrics, customer tags), compiled from the
-// TypeScript in src/api by `npm run build`.
-const api = require('../dist/api');
-
-module.exports = {
-  setup,
-  flush,
-  autoInstrument,
-  AiSdk,
-  AIProviderName,
-  propagateMetadata,
-  client: api.client,
-  api,
-};

package/src/instrumentation/anthropic/get_cache_and_reasoning_telemetry.js

@@ -1,118 +0,0 @@
-'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 CACHE_CREATION_ATTR = 'weflayr.cache.creation';
-const INPUT_TOKENS_ATTR = 'gen_ai.usage.input_tokens';
-const THINKING_TOKENS_ATTR = 'gen_ai.usage.output_tokens_details.thinking_tokens';
-
-// Stamp `usage.cache_creation` verbatim (the written tokens per TTL, billed at
-// different rates); skipped when nothing was written so non-caching calls
-// carry no attribute. The normalizer owns the mapping to TTL tiers.
-function _setCacheCreation(span, cacheCreation) {
-  if (!cacheCreation) return;
-  if (!Object.values(cacheCreation).some(Boolean)) return;
-  span.setAttribute(CACHE_CREATION_ATTR, JSON.stringify(cacheCreation));
-}
-
-// 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);
-  }
-  _setCacheCreation(span, usage.cache_creation);
-  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_cache_config_telemetry.js

@@ -1,90 +0,0 @@
-'use strict';
-
-/**
- * Request-side prompt-caching config capture for Anthropic spans.
- *
- * Anthropic callers opt into caching by placing `cache_control` breakpoints on
- * content blocks (`system` text blocks, message content blocks, tool
- * definitions), each with an optional `ttl` ("5m" default, or "1h"). The
- * traceloop instrumentor never records them, so cache-hit analysis cannot tell
- * what the request asked to cache or for how long.
- *
- * Wrap `startSpan({ type, params })` (covering the streamed and non-streamed
- * paths) to stamp every breakpoint found in the request as
- * `weflayr.cache.breakpoints`: a JSON list of `{location, ttl}` where location
- * is `system`, `messages[i]` or `tools[i]` and `ttl` is the raw cache_control
- * string, omitted when the breakpoint sets none; the normalizer owns the TTL
- * vocabulary.
- */
-
-const BREAKPOINTS_ATTR = 'weflayr.cache.breakpoints';
-
-// A breakpoint as location + the raw cache_control `ttl` string, omitted when
-// the request sets none.
-function _breakpointEntry(location, cacheControl) {
-  const ttl = cacheControl && cacheControl.ttl;
-  return ttl ? { location, ttl: String(ttl) } : { location };
-}
-
-function _cacheControlsInBlocks(blocks) {
-  if (!Array.isArray(blocks)) return [];
-  return blocks.map((block) => block && block.cache_control).filter(Boolean);
-}
-
-// Every `cache_control` breakpoint in the request, as location + the raw
-// `ttl` string (omitted when the breakpoint sets none).
-function extractCacheBreakpoints(params) {
-  const breakpoints = [];
-  for (const cacheControl of _cacheControlsInBlocks(params.system)) {
-    breakpoints.push(_breakpointEntry('system', cacheControl));
-  }
-  (params.messages || []).forEach((message, index) => {
-    for (const cacheControl of _cacheControlsInBlocks(message && message.content)) {
-      breakpoints.push(_breakpointEntry(`messages[${index}]`, cacheControl));
-    }
-  });
-  (params.tools || []).forEach((tool, index) => {
-    if (tool && tool.cache_control) {
-      breakpoints.push(_breakpointEntry(`tools[${index}]`, tool.cache_control));
-    }
-  });
-  return breakpoints;
-}
-
-class AnthropicCacheConfigInstrumentor {
-  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 breakpoints = extractCacheBreakpoints((request && request.params) || {});
-        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 = { AnthropicCacheConfigInstrumentor, extractCacheBreakpoints };

package/src/instrumentation/anthropic/get_streaming_stop_reason_telemetry.js

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

@@ -1,55 +0,0 @@
-'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) {
-          // cache_control is dropped from the stamped definitions — the
-          // breakpoint is captured separately in cache_config.
-          const definitions = tools.map(
-            ({ cache_control: _cacheControl, ...definition }) => definition
-          );
-          span.setAttribute('gen_ai.tool.definitions', JSON.stringify(definitions));
-        }
-      } 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

@@ -1,39 +0,0 @@
-'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 { AnthropicCacheConfigInstrumentor } = require('./get_cache_config_telemetry');
-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 AnthropicCacheConfigInstrumentor(),
-      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 };