weflayr 0.23.0 → 0.24.0

package/src/api/generated/sdk.gen.ts

@@ -2,7 +2,7 @@
 
 import { client } from './client.gen.js';
 import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client/index.js';
-import type { DeleteCustomersTagsData, DeleteCustomersTagsErrors, DeleteCustomersTagsResponses, DeleteKeyMetricsData, DeleteKeyMetricsErrors, DeleteKeyMetricsResponses, DeleteRevenueData, DeleteRevenueErrors, DeleteRevenueResponses, GetCustomersTagsData, GetCustomersTagsErrors, GetCustomersTagsResponses, GetKeyMetricsData, GetKeyMetricsErrors, GetKeyMetricsResponses, GetMarginData, GetMarginErrors, GetMarginResponses, GetRevenueData, GetRevenueErrors, GetRevenueResponses, SetCustomersTagsData, SetCustomersTagsErrors, SetCustomersTagsResponses, SetKeyMetricsData, SetKeyMetricsErrors, SetKeyMetricsResponses, SetRevenueData, SetRevenueErrors, SetRevenueResponses } from './types.gen.js';
+import type { DeleteCustomersTagsData, DeleteCustomersTagsErrors, DeleteCustomersTagsResponses, DeleteKeyMetricsData, DeleteKeyMetricsErrors, DeleteKeyMetricsResponses, DeleteRevenueData, DeleteRevenueErrors, DeleteRevenueResponses, GetCustomersData, GetCustomersErrors, GetCustomersResponses, GetCustomersTagsData, GetCustomersTagsErrors, GetCustomersTagsResponses, GetFeaturesData, GetFeaturesErrors, GetFeaturesResponses, GetKeyMetricsData, GetKeyMetricsErrors, GetKeyMetricsResponses, GetMarginData, GetMarginErrors, GetMarginResponses, GetModelsData, GetModelsErrors, GetModelsResponses, GetProjectData, GetProjectErrors, GetProjectResponses, GetProvidersData, GetProvidersErrors, GetProvidersResponses, GetRevenueData, GetRevenueErrors, GetRevenueResponses, GetTagsData, GetTagsErrors, GetTagsResponses, SetCustomersTagsData, SetCustomersTagsErrors, SetCustomersTagsResponses, SetKeyMetricsData, SetKeyMetricsErrors, SetKeyMetricsResponses, SetRevenueData, SetRevenueErrors, SetRevenueResponses } from './types.gen.js';
 
 export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
     /**
@@ -119,3 +119,57 @@ export const setCustomersTags = <ThrowOnError extends boolean = false>(options:
         ...options.headers
     }
 });
+
+/**
+ * Static identity of the project: name, type, key metrics, environment and creation date.
+ */
+export const getProject = <ThrowOnError extends boolean = false>(options?: Options<GetProjectData, ThrowOnError>): RequestResult<GetProjectResponses, GetProjectErrors, ThrowOnError> => (options?.client ?? client).get<GetProjectResponses, GetProjectErrors, ThrowOnError>({
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/project/',
+    ...options
+});
+
+/**
+ * {key: [values]} facets for run tags and customer tags; pass include_run_tags/include_customer_tags=false to skip either one.
+ */
+export const getTags = <ThrowOnError extends boolean = false>(options?: Options<GetTagsData, ThrowOnError>): RequestResult<GetTagsResponses, GetTagsErrors, ThrowOnError> => (options?.client ?? client).get<GetTagsResponses, GetTagsErrors, ThrowOnError>({
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/tags/',
+    ...options
+});
+
+/**
+ * Every distinct model name seen for the project.
+ */
+export const getModels = <ThrowOnError extends boolean = false>(options?: Options<GetModelsData, ThrowOnError>): RequestResult<GetModelsResponses, GetModelsErrors, ThrowOnError> => (options?.client ?? client).get<GetModelsResponses, GetModelsErrors, ThrowOnError>({
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/models/',
+    ...options
+});
+
+/**
+ * Every distinct provider name seen for the project.
+ */
+export const getProviders = <ThrowOnError extends boolean = false>(options?: Options<GetProvidersData, ThrowOnError>): RequestResult<GetProvidersResponses, GetProvidersErrors, ThrowOnError> => (options?.client ?? client).get<GetProvidersResponses, GetProvidersErrors, ThrowOnError>({
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/providers/',
+    ...options
+});
+
+/**
+ * Every known customer of the project; pass include_customer_tags=false to omit each customer's tags.
+ */
+export const getCustomers = <ThrowOnError extends boolean = false>(options?: Options<GetCustomersData, ThrowOnError>): RequestResult<GetCustomersResponses, GetCustomersErrors, ThrowOnError> => (options?.client ?? client).get<GetCustomersResponses, GetCustomersErrors, ThrowOnError>({
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/customers/',
+    ...options
+});
+
+/**
+ * Every distinct feature tag seen for the project.
+ */
+export const getFeatures = <ThrowOnError extends boolean = false>(options?: Options<GetFeaturesData, ThrowOnError>): RequestResult<GetFeaturesResponses, GetFeaturesErrors, ThrowOnError> => (options?.client ?? client).get<GetFeaturesResponses, GetFeaturesErrors, ThrowOnError>({
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/features/',
+    ...options
+});

package/src/api/generated/types.gen.ts

@@ -68,6 +68,24 @@ export type CustomerMarginRow = {
     profitability_status: 'healthy' | 'watch' | 'at_risk' | 'unprofitable' | 'unknown';
 };
 
+/**
+ * CustomerOutput
+ *
+ * One customer, with its tags when requested (an empty dict otherwise).
+ */
+export type CustomerOutput = {
+    /**
+     * Customer Name
+     */
+    customer_name: string;
+    /**
+     * Customer Tags
+     */
+    customer_tags: {
+        [key: string]: string;
+    };
+};
+
 /**
  * CustomerTags
  *
@@ -104,6 +122,26 @@ export type CustomerTagsOutput = {
     };
 };
 
+/**
+ * CustomersOutput
+ *
+ * The customers GET response: every known customer of the project.
+ */
+export type CustomersOutput = {
+    /**
+     * Customers
+     */
+    customers: Array<CustomerOutput>;
+    /**
+     * Next Cursor
+     */
+    next_cursor: string | null;
+    /**
+     * Has More
+     */
+    has_more: boolean;
+};
+
 /**
  * CustomersUpdatedOutput
  *
@@ -120,6 +158,18 @@ export type CustomersUpdatedOutput = {
     customers_updated: number;
 };
 
+/**
+ * FeaturesOutput
+ *
+ * A features GET response: every distinct feature tag seen for the project.
+ */
+export type FeaturesOutput = {
+    /**
+     * Features
+     */
+    features: Array<string>;
+};
+
 /**
  * InvalidFieldDetail
  *
@@ -265,6 +315,58 @@ export type MarginListOutput = {
     has_more: boolean;
 };
 
+/**
+ * ModelsOutput
+ *
+ * A models GET response: every distinct model name seen for the project.
+ */
+export type ModelsOutput = {
+    /**
+     * Models
+     */
+    models: Array<string>;
+};
+
+/**
+ * ProjectOutput
+ *
+ * A project GET response: static identity of the project.
+ */
+export type ProjectOutput = {
+    /**
+     * Name
+     */
+    name: string;
+    /**
+     * Project Type
+     */
+    project_type: 'revenue' | 'internal';
+    /**
+     * Key Metric Names
+     */
+    key_metric_names: Array<string>;
+    /**
+     * Environment
+     */
+    environment: 'dev' | 'pre-prod' | 'staging' | 'prod';
+    /**
+     * Created At
+     */
+    created_at: string;
+};
+
+/**
+ * ProvidersOutput
+ *
+ * A providers GET response: every distinct provider name seen for the project.
+ */
+export type ProvidersOutput = {
+    /**
+     * Providers
+     */
+    providers: Array<string>;
+};
+
 /**
  * RevenueOrKeyMetricDeletedRowOutput
  *
@@ -460,6 +562,28 @@ export type TagsDeletedOutput = {
     tags_deleted: number;
 };
 
+/**
+ * TagsOutput
+ *
+ * A tags GET response: facets of every tag dimension seen on the project.
+ *
+ * Either field is an empty dict when its include_* flag was false.
+ */
+export type TagsOutput = {
+    /**
+     * Run Tags
+     */
+    run_tags: {
+        [key: string]: Array<string>;
+    };
+    /**
+     * Customer Tags
+     */
+    customer_tags: {
+        [key: string]: Array<string>;
+    };
+};
+
 export type GetMarginData = {
     body?: never;
     path?: never;
@@ -820,3 +944,172 @@ export type SetCustomersTagsResponses = {
 };
 
 export type SetCustomersTagsResponse = SetCustomersTagsResponses[keyof SetCustomersTagsResponses];
+
+export type GetProjectData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/project/';
+};
+
+export type GetProjectErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ApiErrorOutput;
+};
+
+export type GetProjectError = GetProjectErrors[keyof GetProjectErrors];
+
+export type GetProjectResponses = {
+    /**
+     * Success.
+     */
+    200: ProjectOutput;
+};
+
+export type GetProjectResponse = GetProjectResponses[keyof GetProjectResponses];
+
+export type GetTagsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Include run-tag facets. Defaults to true.
+         */
+        include_run_tags?: boolean;
+        /**
+         * Include customer-tag facets. Defaults to true.
+         */
+        include_customer_tags?: boolean;
+    };
+    url: '/tags/';
+};
+
+export type GetTagsErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ApiErrorOutput;
+};
+
+export type GetTagsError = GetTagsErrors[keyof GetTagsErrors];
+
+export type GetTagsResponses = {
+    /**
+     * Success.
+     */
+    200: TagsOutput;
+};
+
+export type GetTagsResponse = GetTagsResponses[keyof GetTagsResponses];
+
+export type GetModelsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/models/';
+};
+
+export type GetModelsErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ApiErrorOutput;
+};
+
+export type GetModelsError = GetModelsErrors[keyof GetModelsErrors];
+
+export type GetModelsResponses = {
+    /**
+     * Success.
+     */
+    200: ModelsOutput;
+};
+
+export type GetModelsResponse = GetModelsResponses[keyof GetModelsResponses];
+
+export type GetProvidersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/providers/';
+};
+
+export type GetProvidersErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ApiErrorOutput;
+};
+
+export type GetProvidersError = GetProvidersErrors[keyof GetProvidersErrors];
+
+export type GetProvidersResponses = {
+    /**
+     * Success.
+     */
+    200: ProvidersOutput;
+};
+
+export type GetProvidersResponse = GetProvidersResponses[keyof GetProvidersResponses];
+
+export type GetCustomersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Opaque cursor from a previous page's next_cursor.
+         */
+        cursor?: string;
+        limit?: number;
+        /**
+         * Include each customer's tags. Defaults to true.
+         */
+        include_customer_tags?: boolean;
+    };
+    url: '/customers/';
+};
+
+export type GetCustomersErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ApiErrorOutput;
+};
+
+export type GetCustomersError = GetCustomersErrors[keyof GetCustomersErrors];
+
+export type GetCustomersResponses = {
+    /**
+     * Success.
+     */
+    200: CustomersOutput;
+};
+
+export type GetCustomersResponse = GetCustomersResponses[keyof GetCustomersResponses];
+
+export type GetFeaturesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/features/';
+};
+
+export type GetFeaturesErrors = {
+    /**
+     * Missing or invalid API key.
+     */
+    401: ApiErrorOutput;
+};
+
+export type GetFeaturesError = GetFeaturesErrors[keyof GetFeaturesErrors];
+
+export type GetFeaturesResponses = {
+    /**
+     * Success.
+     */
+    200: FeaturesOutput;
+};
+
+export type GetFeaturesResponse = GetFeaturesResponses[keyof GetFeaturesResponses];

package/src/auto-instrument.js

@@ -22,6 +22,7 @@ const AiSdk = Object.freeze({
 // OpenAI SDK (OpenAI-compatible endpoint) but reported as itself.
 const AIProviderName = Object.freeze({
   OPENAI: 'openai',
+  AZURE_OPENAI: 'azure',
   ANTHROPIC: 'anthropic',
   BEDROCK: 'bedrock',
   COHERE: 'cohere',

package/src/instrumentation/anthropic/get_cache_and_reasoning_telemetry.js

@@ -18,9 +18,19 @@
 
 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
@@ -35,6 +45,7 @@ function _setUsage(span, usage) {
   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);
   }

package/src/instrumentation/anthropic/get_cache_config_telemetry.js

@@ -0,0 +1,90 @@
+'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_tool_definitions_telemetry.js

@@ -29,7 +29,12 @@ class AnthropicToolDefinitionsInstrumentor {
       try {
         const tools = request && request.params && request.params.tools;
         if (Array.isArray(tools) && tools.length) {
-          span.setAttribute('gen_ai.tool.definitions', JSON.stringify(tools));
+          // 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.

package/src/instrumentation/anthropic/set_telemetry_attributes.js

@@ -10,6 +10,7 @@
  * 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,
@@ -20,6 +21,7 @@ class AnthropicTelemetryInstrumentor {
   constructor() {
     this._subInstrumentors = [
       new AnthropicPromptCachingInstrumentor(),
+      new AnthropicCacheConfigInstrumentor(),
       new AnthropicStreamingStopReasonInstrumentor(),
       new AnthropicToolDefinitionsInstrumentor(),
     ];

package/src/instrumentation/bedrock/get_cache_config_telemetry.js

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

@@ -7,7 +7,9 @@
  * 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
+ * `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.
  *
@@ -19,14 +21,17 @@
 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.
+// 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;
-  if (typeof usage.cacheReadInputTokenCount === 'number' && usage.cacheReadInputTokenCount) {
-    span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, usage.cacheReadInputTokenCount);
+  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 usage.cacheWriteInputTokenCount === 'number' && usage.cacheWriteInputTokenCount) {
-    span.setAttribute(CACHE_CREATION_INPUT_TOKENS_ATTR, usage.cacheWriteInputTokenCount);
+  if (typeof write === 'number' && write) {
+    span.setAttribute(CACHE_CREATION_INPUT_TOKENS_ATTR, write);
   }
 }