weflayr 0.26.1 → 0.28.0

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

@@ -8,7 +8,19 @@
  *     non-streamed cached-prompt tokens (these enrich the traceloop instrumentor
  *     instance, hence the `instrumentation` argument), and
  *   - the request's structured-output schema, and
- *   - Bedrock Mantle's provider attribution and reasoning output.
+ *   - the Responses endpoint, which it wraps but records far less of than the
+ *     Python instrumentor does (and not at all when streamed), and
+ *   - Bedrock Mantle's provider attribution and reasoning output, and
+ *   - the provider-run web search (`web_search_options` and the answer's
+ *     `url_citation` annotations), and
+ *   - the mime type of an inline file (PDF, ...), which it reads from a
+ *     field OpenAI's API does not have and so always records as
+ *     application/octet-stream, and
+ *   - the provider attribution of the vendors served over an
+ *     OpenAI-compatible API (Alibaba Model Studio, xAI), and
+ *   - the billing of the calls to Vertex AI's OpenAI-compatible endpoint, and
+ *   - a `reasoning_content` output part for any provider that returns one, and
+ *   - the service tier the call was served in (flex, priority, ...).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAITelemetryInstrumentor = void 0;
@@ -16,9 +28,16 @@ const get_structured_output_schema_telemetry_1 = require("../shared/get_structur
 const get_audio_telemetry_1 = require("./get_audio_telemetry");
 const get_bedrock_mantle_telemetry_1 = require("./get_bedrock_mantle_telemetry");
 const get_cache_config_telemetry_1 = require("./get_cache_config_telemetry");
+const get_file_part_mime_type_telemetry_1 = require("./get_file_part_mime_type_telemetry");
+const get_openai_compatible_provider_telemetry_1 = require("./get_openai_compatible_provider_telemetry");
+const get_responses_telemetry_1 = require("./get_responses_telemetry");
 const get_embeddings_telemetry_1 = require("./get_embeddings_telemetry");
+const get_reasoning_content_telemetry_1 = require("./get_reasoning_content_telemetry");
+const get_service_tier_telemetry_1 = require("./get_service_tier_telemetry");
 const get_streaming_usage_1 = require("./get_streaming_usage");
 const get_cache_and_reasoning_telemetry_1 = require("./get_cache_and_reasoning_telemetry");
+const get_vertex_openai_compatible_telemetry_1 = require("./get_vertex_openai_compatible_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 OpenAITelemetryInstrumentor {
     _subInstrumentors;
@@ -29,7 +48,15 @@ class OpenAITelemetryInstrumentor {
             new get_streaming_usage_1.OpenAIStreamingUsageInstrumentor(),
             new get_cache_and_reasoning_telemetry_1.OpenAIPromptCachingInstrumentor(),
             new get_cache_config_telemetry_1.OpenAICacheConfigInstrumentor(),
+            new get_responses_telemetry_1.OpenAIResponsesInstrumentor(),
+            new get_file_part_mime_type_telemetry_1.OpenAIFilePartMimeTypeInstrumentor(),
             new get_bedrock_mantle_telemetry_1.OpenAIBedrockMantleInstrumentor(),
+            new get_web_search_telemetry_1.OpenAIWebSearchInstrumentor(),
+            new get_openai_compatible_provider_telemetry_1.OpenAICompatibleProviderInstrumentor(get_openai_compatible_provider_telemetry_1.ALIBABA_PROVIDER),
+            new get_openai_compatible_provider_telemetry_1.OpenAICompatibleProviderInstrumentor(get_openai_compatible_provider_telemetry_1.SPACEXAI_PROVIDER),
+            new get_vertex_openai_compatible_telemetry_1.VertexOpenAICompatibleInstrumentor(),
+            new get_reasoning_content_telemetry_1.OpenAIReasoningContentInstrumentor(),
+            new get_service_tier_telemetry_1.OpenAIServiceTierInstrumentor(),
             new get_structured_output_schema_telemetry_1.TraceloopStructuredOutputSchemaInstrumentor(get_structured_output_schema_telemetry_2.readStructuredOutputSchema),
         ];
     }
@@ -39,8 +66,12 @@ class OpenAITelemetryInstrumentor {
         for (const sub of this._subInstrumentors)
             sub.instrument(instrumentation);
     }
+    // Reversed: several complements patch the same instrumentor methods
+    // (`startSpan`, `_endSpan`), so the patches have to be unwound
+    // last-patched-first or an earlier wrapper is written back over a later one
+    // and stays installed.
     uninstrument() {
-        for (const sub of this._subInstrumentors)
+        for (const sub of [...this._subInstrumentors].reverse())
             sub.uninstrument();
     }
 }

package/dist/src/instrumentation/shared/get_structured_output_schema_telemetry.d.ts

@@ -4,7 +4,7 @@
  * Each provider asks for structured output under its own request field (OpenAI
  * `response_format`, Anthropic `output_config.format`, Cohere `response_format`,
  * Gemini `responseJsonSchema`), but they all serialize the schema into the
- * request the same way - and OpenAI, Anthropic and Vercel bill it as input - so
+ * request the same way - and OpenAI and Anthropic bill it as input - so
  * the complements stamp one provider-agnostic attribute and the worker stores it
  * in `input_structured_output_schema`.
  *

package/dist/src/instrumentation/shared/get_structured_output_schema_telemetry.js

@@ -5,7 +5,7 @@
  * Each provider asks for structured output under its own request field (OpenAI
  * `response_format`, Anthropic `output_config.format`, Cohere `response_format`,
  * Gemini `responseJsonSchema`), but they all serialize the schema into the
- * request the same way - and OpenAI, Anthropic and Vercel bill it as input - so
+ * request the same way - and OpenAI and Anthropic bill it as input - so
  * the complements stamp one provider-agnostic attribute and the worker stores it
  * in `input_structured_output_schema`.
  *

package/dist/src/instrumentation/shared/is_vertex_base_url.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Whether a client calls Google Cloud's Vertex AI.
+ *
+ * Vertex serves partner models through the providers' own clients pointed at a
+ * Vertex AI host: Claude through Anthropic's `AnthropicVertex`, and Grok,
+ * DeepSeek, Llama and the other partner models through the openai client
+ * pointed at Vertex's OpenAI-compatible endpoint. Those calls are billed by
+ * Google at Vertex's prices, so each complement that sees such a client stamps
+ * `weflayr.billing_provider` with `vertex`.
+ */
+export declare const VERTEX_BILLING_PROVIDER = "vertex";
+export declare const BILLING_PROVIDER_ATTR = "weflayr.billing_provider";
+/** Whether a client base URL is a Vertex AI host, e.g.
+ * 'https://us-east5-aiplatform.googleapis.com/v1' -> true. Never a bare
+ * substring match, so 'https://aiplatform.googleapis.com.evil.example' is not
+ * one. */
+export declare function isVertexBaseURL(baseURL: unknown): boolean;

package/dist/src/instrumentation/shared/is_vertex_base_url.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Whether a client calls Google Cloud's Vertex AI.
+ *
+ * Vertex serves partner models through the providers' own clients pointed at a
+ * Vertex AI host: Claude through Anthropic's `AnthropicVertex`, and Grok,
+ * DeepSeek, Llama and the other partner models through the openai client
+ * pointed at Vertex's OpenAI-compatible endpoint. Those calls are billed by
+ * Google at Vertex's prices, so each complement that sees such a client stamps
+ * `weflayr.billing_provider` with `vertex`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BILLING_PROVIDER_ATTR = exports.VERTEX_BILLING_PROVIDER = void 0;
+exports.isVertexBaseURL = isVertexBaseURL;
+exports.VERTEX_BILLING_PROVIDER = 'vertex';
+exports.BILLING_PROVIDER_ATTR = 'weflayr.billing_provider';
+// The global host and the US and EU multi-region hosts. A single Google region
+// is served on its own host, "<region>-aiplatform.googleapis.com".
+const VERTEX_HOSTNAMES = new Set([
+    'aiplatform.googleapis.com',
+    'aiplatform.us.rep.googleapis.com',
+    'aiplatform.eu.rep.googleapis.com',
+]);
+const VERTEX_REGIONAL_HOSTNAME_SUFFIX = '-aiplatform.googleapis.com';
+/** Whether a client base URL is a Vertex AI host, e.g.
+ * 'https://us-east5-aiplatform.googleapis.com/v1' -> true. Never a bare
+ * substring match, so 'https://aiplatform.googleapis.com.evil.example' is not
+ * one. */
+function isVertexBaseURL(baseURL) {
+    if (typeof baseURL !== 'string' || !baseURL)
+        return false;
+    let hostname;
+    try {
+        hostname = new URL(baseURL).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return VERTEX_HOSTNAMES.has(hostname) || hostname.endsWith(VERTEX_REGIONAL_HOSTNAME_SUFFIX);
+}

package/dist/src/otel/propagation.d.ts

@@ -3,25 +3,21 @@ import type { AIProviderName } from '../auto-instrument';
 declare const WEFLAYR_METADATA_CONTEXT_KEY: symbol;
 declare const FEATURE_NAME_ATTR = "weflayr.feature_name";
 declare const CUSTOMER_NAME_ATTR = "weflayr.customer_name";
-declare const PROVIDER_NAME_ATTR = "weflayr.provider_name";
+declare const CALL_NAME_ATTR = "weflayr.call_name";
+declare const BILLING_PROVIDER_ATTR = "weflayr.billing_provider";
 declare const UUID_ATTR = "weflayr.uuid";
 declare const EXTRA_TAG_PREFIX = "weflayr.tag.";
 export interface PropagateMetadataOptions {
     /** Product-side feature triggering the LLM call (e.g. `"onboarding-summary"`). */
     featureName: string;
     /** Name of the end-user / tenant customer the call is made for. */
-    customerName?: string;
-    /** @deprecated Use `customerName` instead. */
-    customerId?: string;
+    customerName: string;
     /**
      * Override for the provider seen on the wire. Set this only if it differs
-     * from the SDK auto-detected by OpenTelemetry — e.g. calls routed through
-     * `vercel_ai_gateway` that proxies to OpenAI/Anthropic but should be
-     * reported as the gateway.
+     * from the SDK auto-detected by OpenTelemetry, e.g. Mistral calls made
+     * through the OpenAI SDK, which should be reported as `mistral`.
      */
     providerNameOverride?: AIProviderName;
-    /** @deprecated Use `providerNameOverride` instead. */
-    providerName?: AIProviderName;
     /**
      * Arbitrary scalar key/value pairs to attach. Values must be `string`,
      * `number`, or `boolean` so they survive the ClickHouse `Map(String,
@@ -29,8 +25,24 @@ export interface PropagateMetadataOptions {
      * here — they have dedicated fields.
      */
     extraTags?: Record<string, string | number | boolean>;
+    /**
+     * The uuid to stamp on every span inside the scope, e.g. one
+     * `createFeatureRunUuid` made where the run started, so the calls of one run
+     * made in several processes, or in several scopes, share it: 32 lowercase
+     * hexadecimal characters. When omitted, each invocation creates its own.
+     */
+    featureRunUuid?: string;
 }
 export declare function getMergedMetadataFromContext(parentContext?: Context): Record<string, unknown>;
+/**
+ * A new feature run uuid, the kind `propagateMetadata` creates for each scope,
+ * e.g. `"3f2b9c1e0d4a4b6f8e7d5c4b3a291807"`.
+ *
+ * Create one where a run starts and pass it as `featureRunUuid` to every
+ * `propagateMetadata` scope of the run, including the ones opened in other
+ * processes, so all its calls are recorded under one feature run.
+ */
+export declare function createFeatureRunUuid(): string;
 /**
  * Attach Weflayr metadata to every LLM span created inside this scope.
  *
@@ -43,4 +55,19 @@ export declare function getMergedMetadataFromContext(parentContext?: Context): R
  */
 export declare function propagateMetadata<T>(options: PropagateMetadataOptions, fn: () => Promise<T> | T): Promise<T> | T;
 export declare function propagateMetadata(options: PropagateMetadataOptions): (target: unknown, key?: string, descriptor?: PropertyDescriptor) => unknown;
-export { WEFLAYR_METADATA_CONTEXT_KEY, FEATURE_NAME_ATTR, CUSTOMER_NAME_ATTR, PROVIDER_NAME_ATTR, UUID_ATTR, EXTRA_TAG_PREFIX, };
+/**
+ * Name the LLM call made inside this scope, e.g. `"summarize_profile"`.
+ *
+ * Callable form: `setCallName(callName, fn)` runs `fn` immediately. Decorator
+ * form: `setCallName(callName)` returns a wrapper usable as a function-decorator
+ * (`@setCallName(...)` on class methods) or as a plain `wrap(fn)` -> wrappedFn
+ * helper.
+ *
+ * Where `featureName` names the product feature a call belongs to, `callName`
+ * names one call within it. The fields of an enclosing `propagateMetadata`
+ * scope are kept, and no new `uuid` is minted, so calls under different names
+ * still share their feature's uuid.
+ */
+export declare function setCallName<T>(callName: string, fn: () => Promise<T> | T): Promise<T> | T;
+export declare function setCallName(callName: string): (target: unknown, key?: string, descriptor?: PropertyDescriptor) => unknown;
+export { WEFLAYR_METADATA_CONTEXT_KEY, FEATURE_NAME_ATTR, CUSTOMER_NAME_ATTR, CALL_NAME_ATTR, BILLING_PROVIDER_ATTR, UUID_ATTR, EXTRA_TAG_PREFIX, };

package/dist/src/otel/propagation.js

@@ -9,6 +9,7 @@
 //   - Replaced Langfuse's fixed schema with Weflayr's structured metadata
 //     (featureName, customerName, providerNameOverride, extraTags) plus an
 //     auto-generated per-call uuid
+//   - Added `setCallName`, a nested scope naming one LLM call
 //   - Removed asBaggage cross-process propagation (not needed yet)
 //   - Removed experiment framework keys
 //   - Structured fields are written under stable `weflayr.*` span attribute
@@ -16,9 +17,11 @@
 //
 // See LICENSE-MIT in the package root for the full license text.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EXTRA_TAG_PREFIX = exports.UUID_ATTR = exports.PROVIDER_NAME_ATTR = exports.CUSTOMER_NAME_ATTR = exports.FEATURE_NAME_ATTR = exports.WEFLAYR_METADATA_CONTEXT_KEY = void 0;
+exports.EXTRA_TAG_PREFIX = exports.UUID_ATTR = exports.BILLING_PROVIDER_ATTR = exports.CALL_NAME_ATTR = exports.CUSTOMER_NAME_ATTR = exports.FEATURE_NAME_ATTR = exports.WEFLAYR_METADATA_CONTEXT_KEY = void 0;
 exports.getMergedMetadataFromContext = getMergedMetadataFromContext;
+exports.createFeatureRunUuid = createFeatureRunUuid;
 exports.propagateMetadata = propagateMetadata;
+exports.setCallName = setCallName;
 const node_crypto_1 = require("node:crypto");
 const api_1 = require("@opentelemetry/api");
 const WEFLAYR_METADATA_CONTEXT_KEY = (0, api_1.createContextKey)('weflayr_metadata');
@@ -27,8 +30,10 @@ const FEATURE_NAME_ATTR = 'weflayr.feature_name';
 exports.FEATURE_NAME_ATTR = FEATURE_NAME_ATTR;
 const CUSTOMER_NAME_ATTR = 'weflayr.customer_name';
 exports.CUSTOMER_NAME_ATTR = CUSTOMER_NAME_ATTR;
-const PROVIDER_NAME_ATTR = 'weflayr.provider_name';
-exports.PROVIDER_NAME_ATTR = PROVIDER_NAME_ATTR;
+const CALL_NAME_ATTR = 'weflayr.call_name';
+exports.CALL_NAME_ATTR = CALL_NAME_ATTR;
+const BILLING_PROVIDER_ATTR = 'weflayr.billing_provider';
+exports.BILLING_PROVIDER_ATTR = BILLING_PROVIDER_ATTR;
 const UUID_ATTR = 'weflayr.uuid';
 exports.UUID_ATTR = UUID_ATTR;
 // Prefix for user-supplied `extraTags` so downstream normalizers can pick
@@ -50,53 +55,64 @@ function _buildAttributes({ featureName, customerName, providerNameOverride, ext
         attributes[`${EXTRA_TAG_PREFIX}${key}`] = value;
     }
     if (providerNameOverride !== undefined && providerNameOverride !== null) {
-        attributes[PROVIDER_NAME_ATTR] = providerNameOverride;
+        attributes[BILLING_PROVIDER_ATTR] = providerNameOverride;
     }
     return attributes;
 }
+// The shape of the uuid createFeatureRunUuid returns, which a uuid passed to
+// propagateMetadata must have too, so every feature run is named the same way.
+const FEATURE_RUN_UUID_PATTERN = /^[0-9a-f]{32}$/;
+/**
+ * A new feature run uuid, the kind `propagateMetadata` creates for each scope,
+ * e.g. `"3f2b9c1e0d4a4b6f8e7d5c4b3a291807"`.
+ *
+ * Create one where a run starts and pass it as `featureRunUuid` to every
+ * `propagateMetadata` scope of the run, including the ones opened in other
+ * processes, so all its calls are recorded under one feature run.
+ */
+function createFeatureRunUuid() {
+    return (0, node_crypto_1.randomUUID)().replace(/-/g, '');
+}
 function propagateMetadata(options, fn) {
-    const { featureName, customerId, providerName } = options ?? {};
-    let { customerName, providerNameOverride } = options ?? {};
-    if (customerId != null) {
-        process.emitWarning('propagateMetadata: `customerId` is deprecated, use `customerName`', 'DeprecationWarning');
-        customerName = customerName ?? customerId;
-    }
-    if (providerName != null) {
-        process.emitWarning('propagateMetadata: `providerName` is deprecated, use `providerNameOverride`', 'DeprecationWarning');
-        providerNameOverride = providerNameOverride ?? providerName;
-    }
+    const { featureName, customerName } = options ?? {};
     if (featureName == null || customerName == null) {
         throw new Error('propagateMetadata: `featureName` and `customerName` are required');
     }
-    const normalizedOptions = { ...options, customerName, providerNameOverride };
+    if (options.featureRunUuid !== undefined &&
+        !FEATURE_RUN_UUID_PATTERN.test(options.featureRunUuid)) {
+        throw new Error('propagateMetadata: `featureRunUuid` must be 32 lowercase hexadecimal characters, ' +
+            `as createFeatureRunUuid() returns, not "${options.featureRunUuid}"`);
+    }
     if (typeof fn === 'function') {
-        return _runWithMetadata(normalizedOptions, fn);
+        return _runWithMetadata(options, fn);
     }
     return function decorator(target, _key, descriptor) {
         if (descriptor && typeof descriptor.value === 'function') {
             const original = descriptor.value;
             descriptor.value = function wrapped(...args) {
-                return _runWithMetadata(normalizedOptions, () => original.apply(this, args));
+                return _runWithMetadata(options, () => original.apply(this, args));
             };
             return descriptor;
         }
         if (typeof target === 'function') {
             return function wrapped(...args) {
-                return _runWithMetadata(normalizedOptions, () => target.apply(this, args));
+                return _runWithMetadata(options, () => target.apply(this, args));
             };
         }
         return target;
     };
 }
 function _runWithMetadata(options, fn) {
-    const { featureName, customerName, providerNameOverride, extraTags } = options;
-    const attributes = _buildAttributes({
+    const { featureName, customerName, providerNameOverride, extraTags, featureRunUuid } = options;
+    return _runWithAttributes(_buildAttributes({
         featureName,
         customerName,
         providerNameOverride,
         extraTags: extraTags ?? {},
-        spanUuid: (0, node_crypto_1.randomUUID)().replace(/-/g, ''),
-    });
+        spanUuid: featureRunUuid ?? createFeatureRunUuid(),
+    }), fn);
+}
+function _runWithAttributes(attributes, fn) {
     const parent = api_1.context.active();
     const merged = { ...getMergedMetadataFromContext(parent), ...attributes };
     const newContext = parent.setValue(WEFLAYR_METADATA_CONTEXT_KEY, merged);
@@ -108,3 +124,27 @@ function _runWithMetadata(options, fn) {
     }
     return api_1.context.with(newContext, fn);
 }
+function setCallName(callName, fn) {
+    if (!callName) {
+        throw new Error('setCallName: `callName` must not be empty');
+    }
+    const attributes = { [CALL_NAME_ATTR]: callName };
+    if (typeof fn === 'function') {
+        return _runWithAttributes(attributes, fn);
+    }
+    return function decorator(target, _key, descriptor) {
+        if (descriptor && typeof descriptor.value === 'function') {
+            const original = descriptor.value;
+            descriptor.value = function wrapped(...args) {
+                return _runWithAttributes(attributes, () => original.apply(this, args));
+            };
+            return descriptor;
+        }
+        if (typeof target === 'function') {
+            return function wrapped(...args) {
+                return _runWithAttributes(attributes, () => target.apply(this, args));
+            };
+        }
+        return target;
+    };
+}

package/dist/src/otel/span-filter.d.ts

@@ -1,3 +1,5 @@
 import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+export declare const SENT_TO_WEFLAYR_GATEWAY_ATTR = "weflayr.sent_to_weflayr_gateway";
 export declare function isKnownLLMInstrumentor(span: ReadableSpan): boolean;
+export declare function wasSentToWeflayrGateway(span: ReadableSpan): boolean;
 export declare function isDefaultExportSpan(span: ReadableSpan): boolean;

package/dist/src/otel/span-filter.js

@@ -15,8 +15,14 @@
 //
 // See LICENSE-MIT in the package root for the full license text.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SENT_TO_WEFLAYR_GATEWAY_ATTR = void 0;
 exports.isKnownLLMInstrumentor = isKnownLLMInstrumentor;
+exports.wasSentToWeflayrGateway = wasSentToWeflayrGateway;
 exports.isDefaultExportSpan = isDefaultExportSpan;
+// Stamped by `enablePropagateMetadataToGateway` on the span of a call sent to
+// the Weflayr AI gateway. The gateway sends that call's telemetry itself, so
+// exporting the span as well would store the same call twice.
+exports.SENT_TO_WEFLAYR_GATEWAY_ATTR = 'weflayr.sent_to_weflayr_gateway';
 const KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [
     'agent_framework',
     'ai',
@@ -56,6 +62,9 @@ function isKnownLLMInstrumentor(span) {
     const scope = span.instrumentationScope.name;
     return KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES.some((prefix) => scope === prefix || scope.startsWith(`${prefix}.`));
 }
+function wasSentToWeflayrGateway(span) {
+    return Boolean(span.attributes[exports.SENT_TO_WEFLAYR_GATEWAY_ATTR]);
+}
 function isDefaultExportSpan(span) {
-    return isKnownLLMInstrumentor(span);
+    return isKnownLLMInstrumentor(span) && !wasSentToWeflayrGateway(span);
 }

package/dist/src/otel/span-processor.d.ts

@@ -6,7 +6,7 @@ export type Tags = Record<string, string | number | boolean>;
 /**
  * Span attributes the mask callback can read or scrub. The OpenTelemetry GenAI
  * semantic-convention keys get autocomplete; the index signature catches user
- * tags and provider-specific attributes (e.g. Vercel AI's `ai.*`).
+ * tags and provider-specific attributes (e.g. `weflayr.*`).
  */
 export interface OtelSpanAttributes {
     'gen_ai.system'?: string;
@@ -43,7 +43,6 @@ export declare class WeflayrSpanProcessor implements SpanProcessor {
     private _mask?;
     private _maskFunctionSource;
     private _shouldExportSpan;
-    private _vercelAiSdkSpanFilter;
     private _openLlmSpans;
     constructor({ exporter, exportMode, defaultTags, mask, shouldExportSpan, }: WeflayrSpanProcessorOptions);
     onStart(span: StartedSpan, parentContext: Context): void;

package/dist/src/otel/span-processor.js

@@ -20,7 +20,7 @@ const api_1 = require("@opentelemetry/api");
 const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
 const propagation_1 = require("./propagation");
 const span_filter_1 = require("./span-filter");
-const vercel_ai_sdk_span_filter_1 = require("./vercel-ai-sdk-span-filter");
+const strip_media_payloads_1 = require("./strip-media-payloads");
 const logger_1 = require("../logger");
 // setup({captureMessageContent: ...}) records the choice in this env var (the
 // official OTel GenAI one). Instrumentors gate content on their own knobs
@@ -30,24 +30,25 @@ const logger_1 = require("../logger");
 exports.CONTENT_CAPTURE_ENV = 'OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT';
 // The new-semconv JSON message attributes and the legacy indexed
 // `gen_ai.prompt.{i}.*` / `gen_ai.completion.{i}.*` attributes - plus the
-// request's tool definitions and structured-output schema (`ai.schema` is the
-// Vercel AI SDK's spelling): their descriptions are prompt content the same
-// way the messages are.
+// request's tool definitions and structured-output schema: their descriptions
+// are prompt content the same way the messages are.
 const CONTENT_ATTRIBUTES = [
     'gen_ai.input.messages',
     'gen_ai.output.messages',
     'gen_ai.system_instructions',
     'gen_ai.tool.definitions',
     'gen_ai.request.structured_output_schema',
-    // The legacy Vercel AI SDK's (ai <= 6) response content. finishReason and
-    // providerMetadata are NOT stripped: metadata and billing, not content.
-    'ai.schema',
-    'ai.response.text',
-    'ai.response.object',
-    'ai.response.reasoning',
-    'ai.response.toolCalls',
+    // The embedded texts of weflayr's own embeddings instrumentors.
+    'weflayr.embeddings.input',
+    // A provider-run web search: the tool's own description, the queries the
+    // answer ran and the pages it read. weflayr.web_search.requests is NOT
+    // stripped: it is how many searches the call is billed for, not content.
+    'weflayr.web_search.tool_definitions',
+    'weflayr.web_search.output_blocks',
+    'weflayr.web_search.options',
+    'weflayr.web_search.citations',
 ];
-const CONTENT_ATTRIBUTE_PREFIXES = ['gen_ai.prompt.', 'gen_ai.completion.', 'ai.prompt'];
+const CONTENT_ATTRIBUTE_PREFIXES = ['gen_ai.prompt.', 'gen_ai.completion.'];
 function _isContentAttribute(key) {
     return (CONTENT_ATTRIBUTES.includes(key) ||
         CONTENT_ATTRIBUTE_PREFIXES.some((prefix) => key.startsWith(prefix)));
@@ -62,7 +63,6 @@ class WeflayrSpanProcessor {
     _mask;
     _maskFunctionSource;
     _shouldExportSpan;
-    _vercelAiSdkSpanFilter;
     // LLM spans we've started but not yet seen end. On forceFlush we end any
     // leftovers with ERROR status — covers cases like openllmetry's anthropic
     // streaming wrapper, which leaks the span when the underlying call
@@ -80,7 +80,6 @@ class WeflayrSpanProcessor {
         this._mask = mask;
         this._maskFunctionSource = mask ? String(mask) : null;
         this._shouldExportSpan = shouldExportSpan ?? span_filter_1.isDefaultExportSpan;
-        this._vercelAiSdkSpanFilter = new vercel_ai_sdk_span_filter_1.VercelAiSdkSpanFilter();
         this._openLlmSpans = new Set();
     }
     onStart(span, parentContext) {
@@ -94,7 +93,6 @@ class WeflayrSpanProcessor {
         if ((0, span_filter_1.isKnownLLMInstrumentor)(span)) {
             this._openLlmSpans.add(span);
         }
-        this._vercelAiSdkSpanFilter.onStart(span);
         (0, logger_1.debug)('span start: name=%s defaultTags=%d propagatedMetadata=%d', span.name, Object.keys(this._defaultTags).length, Object.keys(propagated).length);
         return this._delegate.onStart(span, parentContext);
     }
@@ -102,11 +100,7 @@ class WeflayrSpanProcessor {
         // Same concrete object stored in onStart, viewed here as a ReadableSpan.
         this._openLlmSpans.delete(span);
         try {
-            const vercelVerdict = this._vercelAiSdkSpanFilter.shouldExport(span);
-            if (vercelVerdict === true) {
-                (0, vercel_ai_sdk_span_filter_1.stampVercelGatewayProviderName)(span);
-            }
-            if (vercelVerdict === false || (vercelVerdict === null && !this._shouldExportSpan(span))) {
+            if (!this._shouldExportSpan(span)) {
                 (0, logger_1.debug)('span end: filtered out name=%s scope=%s', span.name, span.instrumentationScope?.name);
                 return;
             }
@@ -121,6 +115,9 @@ class WeflayrSpanProcessor {
                     delete span.attributes[key];
             }
         }
+        else {
+            (0, strip_media_payloads_1.stripMediaPayloads)(span.attributes);
+        }
         if (this._mask) {
             try {
                 const masked = this._mask(span.attributes);

package/dist/src/otel/strip-media-payloads.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Remove media payloads (base64 images, audio, documents) from the message
+ * content span attributes, right before export.
+ *
+ * An inline image, audio clip or document reaches the span in one of five shapes,
+ * depending on the instrumentor: a `blob` part carrying the base64 bytes in
+ * `content` (OpenAI chat completions, Anthropic), a `uri` part whose uri is a
+ * `data:` URI holding the same bytes (OpenAI Responses), Anthropic's own content
+ * block with the bytes under `source.data` (Bedrock), an OpenAI `file` block
+ * with the bytes under `file.file_data`, an OpenAI Responses `input_audio` block
+ * kept whole under `content` with the bytes under `content.input_audio.data`. A single
+ * image is hundreds of kilobytes, so keeping it would make every event on the
+ * queue that much bigger for nothing: the payload is never read back.
+ *
+ * Each of those becomes `{"type": "blob", "mime_type": "<mime_type>"}`, the same
+ * byte-less stub the google, cohere and bedrock instrumentation complements
+ * build themselves: the analyses reading these messages still see that the call
+ * carried content the stored text does not. A `uri` part pointing at a hosted
+ * image is a reference, not a payload, and is kept as is.
+ */
+import type { OtelSpanAttributes } from './span-processor';
+/**
+ * Rewrite in place every message content attribute of `attributes` that carries
+ * media bytes.
+ */
+export declare function stripMediaPayloads(attributes: OtelSpanAttributes): void;