weflayr 0.27.0 → 0.28.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "weflayr",
-    "version": "0.27.0",
+    "version": "0.28.0",
     "description": "Weflayr JS/TS SDK — instrument any LLM client",
     "main": "dist/src/index.js",
     "types": "dist/src/index.d.ts",
@@ -31,8 +31,8 @@
     },
     "dependencies": {
         "@opentelemetry/api": "^1.9.1",
-        "@opentelemetry/exporter-trace-otlp-http": "^0.221.0",
-        "@opentelemetry/instrumentation": "^0.221.0",
+        "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
+        "@opentelemetry/instrumentation": "^0.222.0",
         "@opentelemetry/resources": "^2.8.0",
         "@opentelemetry/sdk-trace-base": "^2.8.0",
         "@opentelemetry/sdk-trace-node": "^2.8.0",

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

@@ -6,7 +6,7 @@ export declare const AiSdk: Readonly<{
     COHERE: "cohere";
     GOOGLE_GENAI: "google-genai";
     ELEVENLABS: "elevenlabs";
-    VERCEL_AI_GATEWAY: "vercel_ai_gateway";
+    MISTRAL: "mistral";
 }>;
 export type AiSdk = (typeof AiSdk)[keyof typeof AiSdk];
 export declare const AIProviderName: Readonly<{
@@ -17,9 +17,10 @@ export declare const AIProviderName: Readonly<{
     COHERE: "cohere";
     ELEVENLABS: "elevenlabs";
     MISTRAL: "mistral";
-    VERCEL_AI_GATEWAY: "vercel_ai_gateway";
-    GEMINI: "gemini";
+    GOOGLE: "google";
     VERTEX: "vertex";
+    ALIBABA: "alibaba";
+    SPACEXAI: "spacexai";
 }>;
 export type AIProviderName = (typeof AIProviderName)[keyof typeof AIProviderName];
 interface RegistryEntry {

package/dist/src/auto-instrument.js

@@ -12,13 +12,13 @@ exports.AiSdk = Object.freeze({
     COHERE: 'cohere',
     GOOGLE_GENAI: 'google-genai',
     ELEVENLABS: 'elevenlabs',
-    VERCEL_AI_GATEWAY: 'vercel_ai_gateway',
+    MISTRAL: 'mistral',
 });
-// Allowed values for `propagateMetadata({ providerName })`: the actual AI
+// Allowed values for `propagateMetadata({ providerNameOverride })`: 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.
+// not SDKs — google-genai is an SDK whose calls are labeled google or vertex,
+// and mistral can also be reached through the OpenAI SDK (OpenAI-compatible
+// endpoint) while being reported as itself.
 exports.AIProviderName = Object.freeze({
     OPENAI: 'openai',
     AZURE_OPENAI: 'azure',
@@ -27,15 +27,16 @@ exports.AIProviderName = Object.freeze({
     COHERE: 'cohere',
     ELEVENLABS: 'elevenlabs',
     MISTRAL: 'mistral',
-    VERCEL_AI_GATEWAY: 'vercel_ai_gateway',
-    GEMINI: 'gemini',
+    GOOGLE: 'google',
     VERTEX: 'vertex',
+    ALIBABA: 'alibaba',
+    SPACEXAI: 'spacexai',
 });
 // 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.
+// third-party instrumentor (ElevenLabs, and Mistral, whose SDK traces itself)
+// instead carry a `requirePath` + `className` pointing at the instrumentor
+// weflayr ships itself; `package` then names the provider SDK.
 const REGISTRY = {
     [exports.AiSdk.OPENAI]: { package: '@traceloop/instrumentation-openai' },
     [exports.AiSdk.ANTHROPIC]: { package: '@traceloop/instrumentation-anthropic' },
@@ -47,10 +48,10 @@ const REGISTRY = {
         requirePath: './instrumentation/elevenlabs/full_instrumentation',
         className: 'ElevenLabsInstrumentor',
     },
-    [exports.AiSdk.VERCEL_AI_GATEWAY]: {
-        package: 'ai',
-        requirePath: './instrumentation/vercel/full_instrumentation',
-        className: 'VercelAiSdkInstrumentor',
+    [exports.AiSdk.MISTRAL]: {
+        package: '@mistralai/mistralai',
+        requirePath: './instrumentation/mistral/full_instrumentation',
+        className: 'MistralInstrumentor',
     },
 };
 exports.REGISTRY = REGISTRY;
@@ -105,10 +106,10 @@ async function _instrumentAiSdk(aiSdk) {
     }
     const entry = REGISTRY[aiSdk];
     if (entry.requirePath) {
-        // No usable third-party instrumentor — use the hand-written one bundled
-        // with weflayr (it covers every endpoint of the provider).
+        // No usable third-party instrumentor: use the one bundled with weflayr
+        // (it covers every endpoint of the provider).
         const Instrumentor = require(entry.requirePath)[entry.className];
-        new Instrumentor().instrument();
+        await new Instrumentor().instrument();
         (0, logger_1.debug)('autoInstrument: registered aiSdk=%s package=%s', aiSdk, entry.package);
         return;
     }

package/dist/src/get-data-uri-mime-type.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Reading the mime type out of a `data:` URI.
+ *
+ * Providers hand inline media to the span in several shapes, and four of them
+ * carry the bytes as a data URI: OpenAI's `image_url.url` and `file.file_data`,
+ * Mistral's `image_url` and `document_url`, and Cohere v2's `image_url.url`.
+ * The instrumentation complements and the span processor all need the mime type
+ * out of those, so they read it here rather than each parsing the URI again.
+ */
+/**
+ * The mime type of a `data:<mime_type>[;base64],<payload>` URI, or null when
+ * the string is not a data URI.
+ *
+ * e.g. `"data:image/png;base64,AAA"` -> `"image/png"`,
+ * `"https://example.com/cat.png"` -> `null`.
+ */
+export declare function getDataUriMimeType(uri: string): string | null;

package/dist/src/get-data-uri-mime-type.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Reading the mime type out of a `data:` URI.
+ *
+ * Providers hand inline media to the span in several shapes, and four of them
+ * carry the bytes as a data URI: OpenAI's `image_url.url` and `file.file_data`,
+ * Mistral's `image_url` and `document_url`, and Cohere v2's `image_url.url`.
+ * The instrumentation complements and the span processor all need the mime type
+ * out of those, so they read it here rather than each parsing the URI again.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDataUriMimeType = getDataUriMimeType;
+const DATA_URI_PREFIX = 'data:';
+/**
+ * The mime type of a `data:<mime_type>[;base64],<payload>` URI, or null when
+ * the string is not a data URI.
+ *
+ * e.g. `"data:image/png;base64,AAA"` -> `"image/png"`,
+ * `"https://example.com/cat.png"` -> `null`.
+ */
+function getDataUriMimeType(uri) {
+    if (!uri.startsWith(DATA_URI_PREFIX))
+        return null;
+    return uri.slice(DATA_URI_PREFIX.length).split(';')[0].split(',')[0];
+}

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.client = exports.api = exports.propagateMetadata = exports.AIProviderName = exports.AiSdk = exports.autoInstrument = exports.flush = exports.setup = void 0;
+exports.client = exports.api = exports.enablePropagateMetadataToGateway = exports.setCallName = exports.propagateMetadata = exports.createFeatureRunUuid = 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; } });
@@ -42,7 +42,11 @@ Object.defineProperty(exports, "autoInstrument", { enumerable: true, get: functi
 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, "createFeatureRunUuid", { enumerable: true, get: function () { return propagation_1.createFeatureRunUuid; } });
 Object.defineProperty(exports, "propagateMetadata", { enumerable: true, get: function () { return propagation_1.propagateMetadata; } });
+Object.defineProperty(exports, "setCallName", { enumerable: true, get: function () { return propagation_1.setCallName; } });
+const propagate_metadata_to_gateway_1 = require("./propagate-metadata-to-gateway");
+Object.defineProperty(exports, "enablePropagateMetadataToGateway", { enumerable: true, get: function () { return propagate_metadata_to_gateway_1.enablePropagateMetadataToGateway; } });
 // Public-API client (revenue, key metrics, customer tags).
 const api = __importStar(require("./api"));
 exports.api = api;

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

@@ -6,7 +6,9 @@
  *   - 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`.
+ *     streamed tool call's `tool_call` part carries no `arguments`. This covers
+ *     both a caller's own `tool_use` block and the `server_tool_use` block of a
+ *     provider-run web search, whose query streams the same way.
  *
  * `_streamingWrapPromise(client, moduleExports, { span, type, promise })`
  * returns `new moduleExports.APIPromise(...)` whose parse step wraps the real

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

@@ -7,7 +7,9 @@
  *   - 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`.
+ *     streamed tool call's `tool_call` part carries no `arguments`. This covers
+ *     both a caller's own `tool_use` block and the `server_tool_use` block of a
+ *     provider-run web search, whose query streams the same way.
  *
  * `_streamingWrapPromise(client, moduleExports, { span, type, promise })`
  * returns `new moduleExports.APIPromise(...)` whose parse step wraps the real
@@ -109,9 +111,10 @@ class AnthropicStreamingAccumulationInstrumentor {
                         for (const [index, argumentsJson] of gaps.toolArgumentsJsonByIndex) {
                             const block = Array.isArray(args.result.content) && args.result.content[index];
                             // Only fill the gap: a block whose input upstream DID accumulate
-                            // (a future version) is left alone.
+                            // (a future version) is left alone. `server_tool_use` is the
+                            // provider-run tool (web search), whose query streams the same way.
                             if (block &&
-                                block.type === 'tool_use' &&
+                                (block.type === 'tool_use' || block.type === 'server_tool_use') &&
                                 (!block.input || !Object.keys(block.input).length)) {
                                 try {
                                     block.input = JSON.parse(argumentsJson);

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

@@ -0,0 +1,32 @@
+/**
+ * Billing attribution for Claude called on Vertex AI through `AnthropicVertex`.
+ *
+ * `AnthropicVertex` (`@anthropic-ai/vertex-sdk`) is Anthropic's client for
+ * Claude on Vertex: the same `Messages` resource as the plain `Anthropic`
+ * client, pointed at a Vertex AI host. The traceloop instrumentor attributes
+ * its calls to "anthropic", which is right for parsing them (the payload and
+ * usage are Anthropic's) but not for pricing them: Google bills them at
+ * Vertex's prices. So their spans get `weflayr.billing_provider` set to
+ * `vertex`, which the worker prices by, while `gen_ai.provider.name`, which it
+ * parses by, stays "anthropic".
+ *
+ * traceloop starts the span in `startSpan`, which is handed the request but not
+ * the client. So the client of each call is recorded, for the duration of the
+ * call, around the method `patchAnthropic` builds for each wrapped `create`,
+ * and read back in `startSpan`, which that method calls synchronously before
+ * the request is sent, the error path included.
+ *
+ * `@anthropic-ai/vertex-sdk` loads `@anthropic-ai/sdk` by its subpaths only
+ * (`@anthropic-ai/sdk/client`, `.../resources/index`), which the traceloop
+ * hook, registered on the main module, never sees: an app that only uses
+ * `AnthropicVertex` would get no span at all. Its `Messages` class is the same
+ * object as the main module's `Anthropic.Messages`, so loading the main module
+ * once here is what gets it patched.
+ */
+export declare class AnthropicVertexBillingInstrumentor {
+    private readonly loadAnthropicSdk;
+    private _patched;
+    constructor(loadAnthropicSdk?: () => void);
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Billing attribution for Claude called on Vertex AI through `AnthropicVertex`.
+ *
+ * `AnthropicVertex` (`@anthropic-ai/vertex-sdk`) is Anthropic's client for
+ * Claude on Vertex: the same `Messages` resource as the plain `Anthropic`
+ * client, pointed at a Vertex AI host. The traceloop instrumentor attributes
+ * its calls to "anthropic", which is right for parsing them (the payload and
+ * usage are Anthropic's) but not for pricing them: Google bills them at
+ * Vertex's prices. So their spans get `weflayr.billing_provider` set to
+ * `vertex`, which the worker prices by, while `gen_ai.provider.name`, which it
+ * parses by, stays "anthropic".
+ *
+ * traceloop starts the span in `startSpan`, which is handed the request but not
+ * the client. So the client of each call is recorded, for the duration of the
+ * call, around the method `patchAnthropic` builds for each wrapped `create`,
+ * and read back in `startSpan`, which that method calls synchronously before
+ * the request is sent, the error path included.
+ *
+ * `@anthropic-ai/vertex-sdk` loads `@anthropic-ai/sdk` by its subpaths only
+ * (`@anthropic-ai/sdk/client`, `.../resources/index`), which the traceloop
+ * hook, registered on the main module, never sees: an app that only uses
+ * `AnthropicVertex` would get no span at all. Its `Messages` class is the same
+ * object as the main module's `Anthropic.Messages`, so loading the main module
+ * once here is what gets it patched.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicVertexBillingInstrumentor = void 0;
+const is_vertex_base_url_1 = require("../shared/is_vertex_base_url");
+// The anthropic client of the Messages call in progress, undefined outside of
+// one. A module variable is enough: it is set and read in the same synchronous
+// stretch of the call.
+let clientOfTheCallInProgress;
+function requireAnthropicSdk() {
+    try {
+        require('@anthropic-ai/sdk');
+    }
+    catch (err) {
+        throw new Error(`weflayr: @anthropic-ai/sdk could not be loaded (${err?.message || err}). ` +
+            'Install it with: npm install @anthropic-ai/sdk');
+    }
+}
+class AnthropicVertexBillingInstrumentor {
+    loadAnthropicSdk;
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    constructor(loadAnthropicSdk = requireAnthropicSdk) {
+        this.loadAnthropicSdk = loadAnthropicSdk;
+    }
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const originalPatchAnthropic = instrumentation.patchAnthropic;
+        const originalStartSpan = instrumentation.startSpan;
+        if (typeof originalPatchAnthropic !== 'function' || typeof originalStartSpan !== 'function') {
+            throw new Error('weflayr: @traceloop/instrumentation-anthropic no longer defines patchAnthropic and ' +
+                'startSpan, so Claude calls made through AnthropicVertex cannot be billed to Vertex.');
+        }
+        instrumentation.patchAnthropic = function patchAnthropicRecordingTheClient(...patchArgs) {
+            const buildTracedMethod = originalPatchAnthropic.apply(this, patchArgs);
+            return (original) => {
+                const tracedMethod = buildTracedMethod(original);
+                return function methodRecordingTheClient(...args) {
+                    const previousClient = clientOfTheCallInProgress;
+                    clientOfTheCallInProgress = this?._client;
+                    try {
+                        return tracedMethod.apply(this, args);
+                    }
+                    finally {
+                        clientOfTheCallInProgress = previousClient;
+                    }
+                };
+            };
+        };
+        this._patched.push([instrumentation, 'patchAnthropic', originalPatchAnthropic]);
+        instrumentation.startSpan = function startSpanBilledToVertex(args) {
+            const span = originalStartSpan.call(this, args);
+            try {
+                if (span?.isRecording?.() && (0, is_vertex_base_url_1.isVertexBaseURL)(clientOfTheCallInProgress?.baseURL)) {
+                    span.setAttribute(is_vertex_base_url_1.BILLING_PROVIDER_ATTR, is_vertex_base_url_1.VERTEX_BILLING_PROVIDER);
+                }
+            }
+            catch {
+                // Never break span creation over an enrichment failure.
+            }
+            return span;
+        };
+        this._patched.push([instrumentation, 'startSpan', originalStartSpan]);
+        // After the two patches above, so the traceloop patch this load triggers
+        // builds its methods through them.
+        this.loadAnthropicSdk();
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of [...this._patched].reverse()) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.AnthropicVertexBillingInstrumentor = AnthropicVertexBillingInstrumentor;

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

@@ -0,0 +1,43 @@
+/**
+ * Provider-run web search capture for Anthropic spans.
+ *
+ * Anthropic runs the search itself when the request carries its server tool
+ * (`{ type: 'web_search_20250305', name: 'web_search', ... }`), and bills every
+ * search the call ran, reported as `usage.server_tool_use.web_search_requests`.
+ *
+ * Unlike the Python instrumentor, `@traceloop/instrumentation-anthropic` does
+ * put the answer's search blocks on the span, but in its own shapes: a
+ * `server_tool_use` block becomes a `server_tool_call` part, and a
+ * `web_search_tool_result` block falls through its unknown-block branch and is
+ * copied verbatim, `encrypted_content` blobs included, several kilobytes per
+ * result, which must never reach the queue. It also drops
+ * `usage.server_tool_use`, so the searches are not billed.
+ *
+ * So this complement does three things, all off `_endSpan`'s accumulated result
+ * (which both the streamed and non-streamed paths reach):
+ *
+ *   1. stamps the request's server tool, the answer's search blocks and the
+ *      billed count under `weflayr.web_search.*`, in Anthropic's own vocabulary,
+ *      for `normalizers/anthropic.py` to map;
+ *   2. drops the `encrypted_content` blob of every result on the way, the same
+ *      rule as inline media;
+ *   3. removes the search blocks from the result before the instrumentor formats
+ *      the output message, so the search is recorded once and in one shape. The
+ *      Python instrumentor writes no such parts, and both SDKs must produce the
+ *      same event for the same call.
+ */
+/** The request's web search server-tool definitions, as sent. A user-defined
+ * function tool carries no `type`, so it never matches. */
+export declare function extractWebSearchToolDefinitions(tools: any): any[];
+/** The answer's search blocks: what the model searched for, and the pages it read
+ * back, with the page blobs dropped. */
+export declare function extractWebSearchOutputBlocks(content: any): any[];
+export declare class AnthropicWebSearchInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}
+/** Stamp the call's searches and the count it is billed for, then take the search
+ * blocks out of the result so the instrumentor's own output message does not
+ * carry them a second time. */
+export declare function stampAndStripSearchBlocks(span: any, result: any): void;

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

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Provider-run web search capture for Anthropic spans.
+ *
+ * Anthropic runs the search itself when the request carries its server tool
+ * (`{ type: 'web_search_20250305', name: 'web_search', ... }`), and bills every
+ * search the call ran, reported as `usage.server_tool_use.web_search_requests`.
+ *
+ * Unlike the Python instrumentor, `@traceloop/instrumentation-anthropic` does
+ * put the answer's search blocks on the span, but in its own shapes: a
+ * `server_tool_use` block becomes a `server_tool_call` part, and a
+ * `web_search_tool_result` block falls through its unknown-block branch and is
+ * copied verbatim, `encrypted_content` blobs included, several kilobytes per
+ * result, which must never reach the queue. It also drops
+ * `usage.server_tool_use`, so the searches are not billed.
+ *
+ * So this complement does three things, all off `_endSpan`'s accumulated result
+ * (which both the streamed and non-streamed paths reach):
+ *
+ *   1. stamps the request's server tool, the answer's search blocks and the
+ *      billed count under `weflayr.web_search.*`, in Anthropic's own vocabulary,
+ *      for `normalizers/anthropic.py` to map;
+ *   2. drops the `encrypted_content` blob of every result on the way, the same
+ *      rule as inline media;
+ *   3. removes the search blocks from the result before the instrumentor formats
+ *      the output message, so the search is recorded once and in one shape. The
+ *      Python instrumentor writes no such parts, and both SDKs must produce the
+ *      same event for the same call.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicWebSearchInstrumentor = void 0;
+exports.extractWebSearchToolDefinitions = extractWebSearchToolDefinitions;
+exports.extractWebSearchOutputBlocks = extractWebSearchOutputBlocks;
+exports.stampAndStripSearchBlocks = stampAndStripSearchBlocks;
+const REQUESTS_ATTR = 'weflayr.web_search.requests';
+const TOOL_DEFINITIONS_ATTR = 'weflayr.web_search.tool_definitions';
+const OUTPUT_BLOCKS_ATTR = 'weflayr.web_search.output_blocks';
+// Anthropic versions its server tools by date, so the type of the web search
+// tool changes with each revision while the prefix stays.
+const WEB_SEARCH_TOOL_TYPE_PREFIX = 'web_search';
+// The answer blocks a server-run search produces: the query the model ran, then
+// the pages it got back.
+const SEARCH_QUERY_BLOCK_TYPE = 'server_tool_use';
+const SEARCH_RESULTS_BLOCK_TYPE = 'web_search_tool_result';
+// Per result, an opaque blob of the page Anthropic read. Nothing reads it back.
+const ENCRYPTED_RESULT_FIELD = 'encrypted_content';
+function isWebSearchBlock(block) {
+    return (!!block && (block.type === SEARCH_QUERY_BLOCK_TYPE || block.type === SEARCH_RESULTS_BLOCK_TYPE));
+}
+/** A `web_search_tool_result` block without the opaque page blob each of its
+ * results carries. */
+function dropEncryptedResults(block) {
+    if (!Array.isArray(block.content))
+        return block;
+    return {
+        ...block,
+        content: block.content.map((result) => {
+            if (!result || typeof result !== 'object')
+                return result;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { [ENCRYPTED_RESULT_FIELD]: _encrypted, ...kept } = result;
+            return kept;
+        }),
+    };
+}
+/** The request's web search server-tool definitions, as sent. A user-defined
+ * function tool carries no `type`, so it never matches. */
+function extractWebSearchToolDefinitions(tools) {
+    if (!Array.isArray(tools))
+        return [];
+    return tools.filter((tool) => tool && typeof tool.type === 'string' && tool.type.startsWith(WEB_SEARCH_TOOL_TYPE_PREFIX));
+}
+/** The answer's search blocks: what the model searched for, and the pages it read
+ * back, with the page blobs dropped. */
+function extractWebSearchOutputBlocks(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter(isWebSearchBlock).map(dropEncryptedResults);
+}
+class AnthropicWebSearchInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals have changed shape:
+    // the worst case is a missing web search, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        // Request side: the same `startSpan(request)` the tool-definitions
+        // complement wraps, for both the streamed and non-streamed paths.
+        const startSpanOriginal = instrumentation.startSpan;
+        if (typeof startSpanOriginal === 'function') {
+            instrumentation.startSpan = function startSpanWithWebSearch(request) {
+                const span = startSpanOriginal.call(this, request);
+                try {
+                    const definitions = extractWebSearchToolDefinitions(request?.params?.tools);
+                    if (definitions.length) {
+                        span.setAttribute(TOOL_DEFINITIONS_ATTR, JSON.stringify(definitions));
+                    }
+                }
+                catch {
+                    // Never break span creation over an enrichment failure.
+                }
+                return span;
+            };
+            this._patched.push([instrumentation, 'startSpan', startSpanOriginal]);
+        }
+        // Response side: the accumulated result, before the output message is
+        // formatted from it.
+        const endSpanOriginal = instrumentation._endSpan;
+        if (typeof endSpanOriginal === 'function') {
+            instrumentation._endSpan = function endSpanWithWebSearch(args) {
+                try {
+                    stampAndStripSearchBlocks(args && args.span, args && args.result);
+                }
+                catch {
+                    // Never break span finalization over an enrichment failure.
+                }
+                return endSpanOriginal.call(this, args);
+            };
+            this._patched.push([instrumentation, '_endSpan', endSpanOriginal]);
+        }
+    }
+    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].reverse()) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.AnthropicWebSearchInstrumentor = AnthropicWebSearchInstrumentor;
+/** Stamp the call's searches and the count it is billed for, then take the search
+ * blocks out of the result so the instrumentor's own output message does not
+ * carry them a second time. */
+function stampAndStripSearchBlocks(span, result) {
+    if (!span || !span.isRecording || !span.isRecording() || !result)
+        return;
+    const requests = result.usage?.server_tool_use?.web_search_requests;
+    if (requests)
+        span.setAttribute(REQUESTS_ATTR, requests);
+    const blocks = extractWebSearchOutputBlocks(result.content);
+    if (!blocks.length)
+        return;
+    span.setAttribute(OUTPUT_BLOCKS_ATTR, JSON.stringify(blocks));
+    result.content = result.content.filter((block) => !isWebSearchBlock(block));
+}

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

@@ -4,8 +4,11 @@
  * 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 structured-output schema, and the streamed stop reason and
- * tool-call arguments (its stream accumulator drops both).
+ * definitions and structured-output schema, the streamed stop reason and
+ * tool-call arguments (its stream accumulator drops both), and the provider-run
+ * web search (the tool's type, the queries the answer ran and the searches
+ * Anthropic bills for), and the billing of the calls `AnthropicVertex` makes
+ * to Claude on Vertex AI, which it attributes to Anthropic.
  */
 export declare class AnthropicTelemetryInstrumentor {
     private _subInstrumentors;

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

@@ -5,8 +5,11 @@
  * 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 structured-output schema, and the streamed stop reason and
- * tool-call arguments (its stream accumulator drops both).
+ * definitions and structured-output schema, the streamed stop reason and
+ * tool-call arguments (its stream accumulator drops both), and the provider-run
+ * web search (the tool's type, the queries the answer ran and the searches
+ * Anthropic bills for), and the billing of the calls `AnthropicVertex` makes
+ * to Claude on Vertex AI, which it attributes to Anthropic.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnthropicTelemetryInstrumentor = void 0;
@@ -15,16 +18,25 @@ const get_cache_config_telemetry_1 = require("./get_cache_config_telemetry");
 const get_cache_and_reasoning_telemetry_1 = require("./get_cache_and_reasoning_telemetry");
 const get_streaming_accumulation_telemetry_1 = require("./get_streaming_accumulation_telemetry");
 const get_tool_definitions_telemetry_1 = require("./get_tool_definitions_telemetry");
+const get_vertex_billing_telemetry_1 = require("./get_vertex_billing_telemetry");
+const get_web_search_telemetry_1 = require("./get_web_search_telemetry");
 const get_structured_output_schema_telemetry_2 = require("./get_structured_output_schema_telemetry");
 class AnthropicTelemetryInstrumentor {
     _subInstrumentors;
     constructor() {
+        // Order matters between the last two of these three: each wraps `_endSpan`
+        // and does its own work BEFORE delegating, so the one registered LAST runs
+        // FIRST. The web-search complement reads the streamed `server_tool_use`
+        // block's query, which the streamed-accumulation one fills in, so
+        // accumulation has to be registered after it to run before it.
         this._subInstrumentors = [
             new get_cache_and_reasoning_telemetry_1.AnthropicPromptCachingInstrumentor(),
             new get_cache_config_telemetry_1.AnthropicCacheConfigInstrumentor(),
-            new get_streaming_accumulation_telemetry_1.AnthropicStreamingAccumulationInstrumentor(),
             new get_tool_definitions_telemetry_1.AnthropicToolDefinitionsInstrumentor(),
+            new get_web_search_telemetry_1.AnthropicWebSearchInstrumentor(),
+            new get_streaming_accumulation_telemetry_1.AnthropicStreamingAccumulationInstrumentor(),
             new get_structured_output_schema_telemetry_1.TraceloopStructuredOutputSchemaInstrumentor(get_structured_output_schema_telemetry_2.readStructuredOutputSchema),
+            new get_vertex_billing_telemetry_1.AnthropicVertexBillingInstrumentor(),
         ];
     }
     instrument(instrumentation) {
@@ -32,7 +44,8 @@ class AnthropicTelemetryInstrumentor {
             sub.instrument(instrumentation);
     }
     uninstrument() {
-        for (const sub of this._subInstrumentors)
+        // Newest first: several of them patch the same function.
+        for (const sub of [...this._subInstrumentors].reverse())
             sub.uninstrument();
     }
 }