weflayr 0.24.0 → 0.26.0

package/dist/{api → src/api}/makeEndpoint.js

@@ -11,9 +11,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeEndpoint = makeEndpoint;
 const caseConversion_1 = require("./caseConversion");
-function makeEndpoint(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-wireFn) {
+function makeEndpoint(wireFn) {
     return async (options) => {
         const wireOptions = { ...options };
         for (const key of ['body', 'path', 'query']) {

package/dist/src/auto-instrument.d.ts

@@ -0,0 +1,42 @@
+import { type SetupOptions } from './setup';
+export declare const AiSdk: Readonly<{
+    OPENAI: "openai";
+    ANTHROPIC: "anthropic";
+    BEDROCK: "bedrock";
+    COHERE: "cohere";
+    GOOGLE_GENAI: "google-genai";
+    ELEVENLABS: "elevenlabs";
+    VERCEL_AI_GATEWAY: "vercel_ai_gateway";
+}>;
+export type AiSdk = (typeof AiSdk)[keyof typeof AiSdk];
+export declare const AIProviderName: Readonly<{
+    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";
+}>;
+export type AIProviderName = (typeof AIProviderName)[keyof typeof AIProviderName];
+interface RegistryEntry {
+    package: string;
+    requirePath?: string;
+    className?: string;
+}
+declare const REGISTRY: Record<string, RegistryEntry>;
+export interface AutoInstrumentOptions extends Partial<SetupOptions> {
+    aiSdks: AiSdk | AiSdk[];
+}
+/**
+ * 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.
+ */
+export declare function autoInstrument({ aiSdks, ...options }: AutoInstrumentOptions): Promise<void>;
+export { REGISTRY };

package/dist/src/auto-instrument.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTRY = exports.AIProviderName = exports.AiSdk = void 0;
+exports.autoInstrument = autoInstrument;
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const logger_1 = require("./logger");
+const setup_1 = require("./setup");
+exports.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.
+exports.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 = {
+    [exports.AiSdk.OPENAI]: { package: '@traceloop/instrumentation-openai' },
+    [exports.AiSdk.ANTHROPIC]: { package: '@traceloop/instrumentation-anthropic' },
+    [exports.AiSdk.BEDROCK]: { package: '@traceloop/instrumentation-bedrock' },
+    [exports.AiSdk.COHERE]: { package: '@traceloop/instrumentation-cohere' },
+    [exports.AiSdk.GOOGLE_GENAI]: { package: '@traceloop/instrumentation-google-generativeai' },
+    [exports.AiSdk.ELEVENLABS]: {
+        package: '@elevenlabs/elevenlabs-js',
+        requirePath: './instrumentation/elevenlabs/full_instrumentation',
+        className: 'ElevenLabsInstrumentor',
+    },
+    [exports.AiSdk.VERCEL_AI_GATEWAY]: {
+        package: 'ai',
+        requirePath: './instrumentation/vercel/full_instrumentation',
+        className: 'VercelAiSdkInstrumentor',
+    },
+};
+exports.REGISTRY = REGISTRY;
+// 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 = {
+    [exports.AiSdk.OPENAI]: {
+        requirePath: './instrumentation/openai/set_telemetry_attributes',
+        className: 'OpenAITelemetryInstrumentor',
+    },
+    [exports.AiSdk.ANTHROPIC]: {
+        requirePath: './instrumentation/anthropic/set_telemetry_attributes',
+        className: 'AnthropicTelemetryInstrumentor',
+    },
+    [exports.AiSdk.BEDROCK]: {
+        requirePath: './instrumentation/bedrock/set_telemetry_attributes',
+        className: 'BedrockTelemetryInstrumentor',
+    },
+    [exports.AiSdk.COHERE]: {
+        requirePath: './instrumentation/cohere/set_telemetry_attributes',
+        className: 'CohereTelemetryInstrumentor',
+    },
+    [exports.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();
+        (0, logger_1.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);
+    (0, instrumentation_1.registerInstrumentations)({ instrumentations: [instrumentation] });
+    const complementary = COMPLEMENTARY_INSTRUMENTOR[aiSdk];
+    if (complementary) {
+        const InstrumentorClass = require(complementary.requirePath)[complementary.className];
+        new InstrumentorClass().instrument(instrumentation);
+    }
+    (0, logger_1.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 (!setup_1._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];
+        }
+        (0, setup_1.setup)(setupOptions);
+    }
+    const list = Array.isArray(aiSdks) ? aiSdks : [aiSdks];
+    for (const aiSdk of list) {
+        await _instrumentAiSdk(aiSdk);
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,9 @@
+import { setup, flush, type SetupOptions } from './setup';
+import { autoInstrument, AiSdk, AIProviderName } from './auto-instrument';
+import { propagateMetadata, type PropagateMetadataOptions } from './otel/propagation';
+import type { Tags, OtelSpanAttributes } from './otel/span-processor';
+import * as api from './api';
+export { setup, flush, autoInstrument, AiSdk, AIProviderName, propagateMetadata, api };
+export type { SetupOptions, PropagateMetadataOptions, Tags, OtelSpanAttributes };
+export declare const client: typeof api.client;
+export type { ApiClientOptions } from './api';

package/dist/src/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = exports.api = exports.propagateMetadata = exports.AIProviderName = exports.AiSdk = exports.autoInstrument = exports.flush = exports.setup = void 0;
+const setup_1 = require("./setup");
+Object.defineProperty(exports, "setup", { enumerable: true, get: function () { return setup_1.setup; } });
+Object.defineProperty(exports, "flush", { enumerable: true, get: function () { return setup_1.flush; } });
+const auto_instrument_1 = require("./auto-instrument");
+Object.defineProperty(exports, "autoInstrument", { enumerable: true, get: function () { return auto_instrument_1.autoInstrument; } });
+Object.defineProperty(exports, "AiSdk", { enumerable: true, get: function () { return auto_instrument_1.AiSdk; } });
+Object.defineProperty(exports, "AIProviderName", { enumerable: true, get: function () { return auto_instrument_1.AIProviderName; } });
+const propagation_1 = require("./otel/propagation");
+Object.defineProperty(exports, "propagateMetadata", { enumerable: true, get: function () { return propagation_1.propagateMetadata; } });
+// Public-API client (revenue, key metrics, customer tags).
+const api = __importStar(require("./api"));
+exports.api = api;
+exports.client = api.client;

package/dist/src/instrumentation/anthropic/get_cache_and_reasoning_telemetry.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+export declare class AnthropicPromptCachingInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

package/dist/src/instrumentation/anthropic/get_cache_and_reasoning_telemetry.js

@@ -0,0 +1,114 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicPromptCachingInstrumentor = void 0;
+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 {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _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 = [];
+    }
+}
+exports.AnthropicPromptCachingInstrumentor = AnthropicPromptCachingInstrumentor;

package/dist/src/instrumentation/anthropic/get_cache_config_telemetry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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) or as a top-level request parameter (automatic caching: the
+ * provider places the breakpoint on the last cacheable block), 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]`, `tools[i]` or `auto_last_block` (the top-level
+ * parameter) and `ttl` is the raw cache_control string, omitted when the
+ * breakpoint sets none; the normalizer owns the TTL vocabulary.
+ */
+export interface CacheBreakpoint {
+    location: string;
+    ttl?: string;
+}
+export declare function extractCacheBreakpoints(params: any): CacheBreakpoint[];
+export declare class AnthropicCacheConfigInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

package/dist/src/instrumentation/anthropic/get_cache_config_telemetry.js

@@ -0,0 +1,92 @@
+"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) or as a top-level request parameter (automatic caching: the
+ * provider places the breakpoint on the last cacheable block), 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]`, `tools[i]` or `auto_last_block` (the top-level
+ * parameter) and `ttl` is the raw cache_control string, omitted when the
+ * breakpoint sets none; the normalizer owns the TTL vocabulary.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicCacheConfigInstrumentor = void 0;
+exports.extractCacheBreakpoints = extractCacheBreakpoints;
+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));
+        }
+    });
+    if (params.cache_control) {
+        breakpoints.push(_breakpointEntry('auto_last_block', params.cache_control));
+    }
+    return breakpoints;
+}
+class AnthropicCacheConfigInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _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() {
+        // Restore newest first, so a double instrument() unwinds back to the
+        // true original instead of reinstalling the first wrapper.
+        for (const [owner, methodName, original] of this._patched.slice().reverse()) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.AnthropicCacheConfigInstrumentor = AnthropicCacheConfigInstrumentor;

package/dist/src/instrumentation/anthropic/get_streaming_accumulation_telemetry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Streamed-accumulation gap filling for the Anthropic chat span.
+ *
+ * `@traceloop/instrumentation-anthropic` accumulates a streamed response into a
+ * result object but drops two things on the way:
+ *   - the `message_delta` chunk's `delta.stop_reason`, so streamed spans format
+ *     their output message with an empty `finish_reason`, and
+ *   - the `content_block_delta` chunks' `input_json_delta` fragments, so a
+ *     streamed tool call's `tool_call` part carries no `arguments`.
+ *
+ * `_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 both — which are then
+ * injected into the accumulated result just before `_endSpan` formats the
+ * output message.
+ */
+export declare class AnthropicStreamingAccumulationInstrumentor {
+    private _patched;
+    private _gapsBySpan;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}