weflayr 0.27.0 → 0.28.0

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

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Provider-run web search (Google Search grounding) capture for Gemini spans.
+ *
+ * Gemini runs the search itself when the request config carries the
+ * `googleSearch` tool, and bills the call once per grounded request whatever
+ * number of queries it ran. Neither instrumentor records any of it: the
+ * `googleSearch` tool is nowhere in the span, `candidates[].groundingMetadata`
+ * is dropped, and so is `usageMetadata.toolUsePromptTokenCount`, input tokens
+ * the call is billed for, counted SEPARATELY from `promptTokenCount`, so a
+ * 14-token prompt that grounds bills 14 + 65.
+ *
+ * All three are stamped under `weflayr.web_search.*`; `normalizers/google.py`
+ * maps them to the shape every provider's web search is stored in.
+ *
+ * The `@google/genai` client answers in camelCase where the Python one answers
+ * in snake_case, so the stamped JSON is written in snake_case: both SDKs must
+ * produce the same event for the same call, and the normalizer reads one
+ * spelling.
+ *
+ * `groundingMetadata.searchEntryPoint` is not stamped: it is several kilobytes
+ * of styled HTML for rendering Google's "Search suggestions" widget, which
+ * nothing reads back.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractWebSearchToolDefinitions = extractWebSearchToolDefinitions;
+exports.setWebSearchToolTelemetry = setWebSearchToolTelemetry;
+exports.extractGroundingBlocks = extractGroundingBlocks;
+exports.setWebSearchResultTelemetry = setWebSearchResultTelemetry;
+const TOOL_DEFINITIONS_ATTR = 'weflayr.web_search.tool_definitions';
+const OUTPUT_BLOCKS_ATTR = 'weflayr.web_search.output_blocks';
+const REQUESTS_ATTR = 'weflayr.web_search.requests';
+const TOOL_USE_PROMPT_TOKENS_ATTR = 'weflayr.web_search.tool_use_prompt_tokens';
+// The config fields naming Google's own search tool, as the client spells them
+// and as the stored attribute does. googleSearch is the current one;
+// googleSearchRetrieval is what Gemini 1.5 took, still accepted, and grounds
+// the same way.
+const WEB_SEARCH_TOOL_FIELDS = [
+    ['googleSearch', 'google_search'],
+    ['googleSearchRetrieval', 'google_search_retrieval'],
+];
+/** `value` with every key spelled snake_case, recursing into objects and arrays.
+ * The JS client takes the tool's settings in camelCase (`timeRangeFilter`)
+ * where the Python one takes them in snake_case and dumps them as it took
+ * them, so without this the two SDKs would store the same request's settings
+ * under different names. */
+function withSnakeCaseKeys(value) {
+    if (Array.isArray(value))
+        return value.map(withSnakeCaseKeys);
+    if (!value || typeof value !== 'object')
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, nested]) => [
+        key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`),
+        withSnakeCaseKeys(nested),
+    ]));
+}
+/** The request's Google Search tools, as configured, under the names the Python
+ * SDK stamps. e.g. a config carrying `{ tools: [{ googleSearch: {} }] }` ->
+ * `[{ google_search: {} }]`, and one setting a time range ->
+ * `[{ google_search: { time_range_filter: {...} } }]`. */
+function extractWebSearchToolDefinitions(config) {
+    const tools = config && config.tools;
+    if (!Array.isArray(tools))
+        return [];
+    const definitions = [];
+    for (const tool of tools) {
+        if (!tool)
+            continue;
+        for (const [clientField, storedField] of WEB_SEARCH_TOOL_FIELDS) {
+            if (tool[clientField] !== undefined && tool[clientField] !== null) {
+                definitions.push({ [storedField]: withSnakeCaseKeys(tool[clientField]) });
+            }
+        }
+    }
+    return definitions;
+}
+function setWebSearchToolTelemetry(span, config) {
+    if (!span || !span.isRecording || !span.isRecording() || !config)
+        return;
+    const definitions = extractWebSearchToolDefinitions(config);
+    if (definitions.length) {
+        span.setAttribute(TOOL_DEFINITIONS_ATTR, JSON.stringify(definitions));
+    }
+}
+/** The queries and pages of a grounded candidate, in the snake_case shape the
+ * normalizer reads. Returns an empty array when nothing was grounded. */
+function extractGroundingBlocks(response) {
+    for (const candidate of (response && response.candidates) || []) {
+        const grounding = candidate && candidate.groundingMetadata;
+        if (!grounding)
+            continue;
+        const queries = grounding.webSearchQueries || [];
+        const chunks = grounding.groundingChunks || [];
+        if (!queries.length && !chunks.length)
+            continue;
+        return [
+            {
+                web_search_queries: queries,
+                // The chunk's own `web: {uri, title}` shape is already the same in both
+                // clients, so it is kept verbatim.
+                grounding_chunks: chunks,
+            },
+        ];
+    }
+    return [];
+}
+/** Stamp what the grounded answer searched for, that it is billed for one
+ * grounded request, and the input tokens the search results added.
+ *
+ * Over a stream each chunk re-reports the grounding gathered so far, so the
+ * attribute is re-stamped rather than accumulated. */
+function setWebSearchResultTelemetry(span, response) {
+    if (!span || !span.isRecording || !span.isRecording())
+        return;
+    const blocks = extractGroundingBlocks(response);
+    if (blocks.length) {
+        span.setAttribute(OUTPUT_BLOCKS_ATTR, JSON.stringify(blocks));
+        // Google bills a grounded request once, however many queries it ran.
+        span.setAttribute(REQUESTS_ATTR, 1);
+    }
+    const toolUsePromptTokens = response && response.usageMetadata?.toolUsePromptTokenCount;
+    if (toolUsePromptTokens) {
+        span.setAttribute(TOOL_USE_PROMPT_TOKENS_ATTR, toolUsePromptTokens);
+    }
+}

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

@@ -3,8 +3,8 @@
  *
  * Wires every weflayr-supplied patch the traceloop Google instrumentor misses:
  *   - chat span enrichment (one wrap of generateContent{,Stream}Internal that
- *     stamps provider name + audio tokens + cache tokens — see the get_*_telemetry
- *     files), and
+ *     stamps provider name + audio tokens + cache tokens + the provider-run web
+ *     search, see the get_*_telemetry files), and
  *   - the embeddings endpoint it doesn't cover at all.
  *
  * The public arrows delegate to these private prototype methods while the

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

@@ -4,8 +4,8 @@
  *
  * Wires every weflayr-supplied patch the traceloop Google instrumentor misses:
  *   - chat span enrichment (one wrap of generateContent{,Stream}Internal that
- *     stamps provider name + audio tokens + cache tokens — see the get_*_telemetry
- *     files), and
+ *     stamps provider name + audio tokens + cache tokens + the provider-run web
+ *     search, see the get_*_telemetry files), and
  *   - the embeddings endpoint it doesn't cover at all.
  *
  * The public arrows delegate to these private prototype methods while the
@@ -19,6 +19,7 @@ const get_audio_telemetry_1 = require("./get_audio_telemetry");
 const get_cache_telemetry_1 = require("./get_cache_telemetry");
 const get_reasoning_telemetry_1 = require("./get_reasoning_telemetry");
 const get_structured_output_schema_telemetry_1 = require("./get_structured_output_schema_telemetry");
+const get_web_search_telemetry_1 = require("./get_web_search_telemetry");
 const get_embeddings_telemetry_1 = require("./get_embeddings_telemetry");
 const get_cache_operations_telemetry_1 = require("./get_cache_operations_telemetry");
 class GoogleTelemetryInstrumentor {
@@ -57,11 +58,13 @@ class GoogleTelemetryInstrumentor {
             const requestConfig = args[0] && args[0].config;
             (0, get_cache_telemetry_1.setCacheConfigTelemetry)(span, requestConfig);
             (0, get_structured_output_schema_telemetry_1.setInputStructuredOutputSchemaTelemetry)(span, requestConfig);
+            (0, get_web_search_telemetry_1.setWebSearchToolTelemetry)(span, requestConfig);
             if (!stream) {
                 return Promise.resolve(original.apply(this, args)).then((response) => {
                     (0, get_audio_telemetry_1.setAudioTelemetry)(span, response);
                     (0, get_cache_telemetry_1.setCacheTelemetry)(span, response);
                     (0, get_reasoning_telemetry_1.setReasoningTelemetry)(span, response);
+                    (0, get_web_search_telemetry_1.setWebSearchResultTelemetry)(span, response);
                     return response;
                 });
             }
@@ -76,6 +79,7 @@ class GoogleTelemetryInstrumentor {
                         try {
                             (0, get_cache_telemetry_1.setCacheTelemetry)(span, chunk);
                             (0, get_reasoning_telemetry_1.setReasoningTelemetry)(span, chunk);
+                            (0, get_web_search_telemetry_1.setWebSearchResultTelemetry)(span, chunk);
                         }
                         catch {
                             // Never break the caller's stream over an enrichment failure.

package/dist/src/instrumentation/mistral/full_instrumentation.d.ts

@@ -0,0 +1,60 @@
+/**
+ * OTel instrumentor for the Mistral SDK, backed by its built-in tracing.
+ *
+ * `@mistralai/mistralai` (v2) ships its own OpenTelemetry tracing: a
+ * `TracingHook` that opens one `gen_ai.*` span per request, following the
+ * GenAI semantic conventions, including token usage on streaming responses and
+ * error details on failures. It sends its spans to the global TracerProvider
+ * (the one `weflayr.setup()` installs) only once the `MISTRAL_SDK_TELEMETRY`
+ * environment variable says "global", which this instrumentor sets unless the
+ * user chose otherwise. traceloop ships no Mistral instrumentor.
+ *
+ * The package is ESM only and keeps the functions that build the span
+ * attributes to itself, so the complements below wrap the methods of its
+ * exported `TracingHook` class, which hand over the span and the request body:
+ *
+ * - The built-in tracing always records message content
+ *   (`gen_ai.input.messages` / `gen_ai.output.messages`), ignoring the standard
+ *   `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` switch that
+ *   `weflayr.setup({ captureMessageContent })` drives. Unless capture is
+ *   enabled, the content attributes are removed from the span once the request
+ *   is traced, and never set on it afterwards.
+ * - It forwards the API's raw `finish_reason` ("tool_calls") and the tool call
+ *   `arguments` as the raw JSON string, where the other instrumentors emit the
+ *   OTel GenAI "tool_call" and a parsed arguments object. `gen_ai.output.messages`
+ *   (and `gen_ai.response.finish_reasons`) are rewritten to that shape as they
+ *   are set, so a Mistral tool call normalizes like every other provider's.
+ * - On the request, it records the sampling params, messages and tool
+ *   definitions but not the requested structured-output schema, the
+ *   `reasoning_effort` or the `prompt_cache_key`: they are read off the request
+ *   body (the effort lands on `gen_ai.request.reasoning_effort` and the key on
+ *   `weflayr.cache.key`, as on OpenAI spans). It also misses the embeddings
+ *   input, stamped here as `weflayr.embeddings.input`, the way the other
+ *   embeddings instrumentors do, and records media parts other than images
+ *   under a bare block type with no mime type, which is repaired (see
+ *   `get_input_message_content_telemetry.ts`).
+ * - On the response, it only forwards the flat `prompt_tokens` /
+ *   `completion_tokens` counts, so prompt-cache reads never reach the span:
+ *   `usage.prompt_tokens_details.cached_tokens` is read off the response body
+ *   (or off the streamed chunks as they pass) and stamped as
+ *   `gen_ai.usage.cache_read_input_tokens`.
+ *
+ * Mistral's models on Vertex AI, called through `MistralGCP`, get the same
+ * tracing from `get_vertex_telemetry.ts`.
+ */
+import { type LoadModule } from './get_vertex_telemetry';
+export declare const MISTRAL_SDK_TELEMETRY_ENV = "MISTRAL_SDK_TELEMETRY";
+export declare const MISTRAL_TRACING_HOOK_MODULE = "@mistralai/mistralai/hooks/tracing";
+export declare class MistralInstrumentor {
+    private readonly loadModule;
+    private readonly canTheSdkLoadTheOtelApi;
+    private static activeInstance;
+    private _tracingHookClass;
+    private _originalBeforeRequest;
+    private _originalAfterSuccess;
+    private _ownsTelemetryEnv;
+    private readonly _vertexInstrumentor;
+    constructor(loadModule?: LoadModule, canTheSdkLoadTheOtelApi?: () => boolean);
+    instrument(): Promise<void>;
+    uninstrument(): void;
+}

package/dist/src/instrumentation/mistral/full_instrumentation.js

@@ -0,0 +1,364 @@
+"use strict";
+/**
+ * OTel instrumentor for the Mistral SDK, backed by its built-in tracing.
+ *
+ * `@mistralai/mistralai` (v2) ships its own OpenTelemetry tracing: a
+ * `TracingHook` that opens one `gen_ai.*` span per request, following the
+ * GenAI semantic conventions, including token usage on streaming responses and
+ * error details on failures. It sends its spans to the global TracerProvider
+ * (the one `weflayr.setup()` installs) only once the `MISTRAL_SDK_TELEMETRY`
+ * environment variable says "global", which this instrumentor sets unless the
+ * user chose otherwise. traceloop ships no Mistral instrumentor.
+ *
+ * The package is ESM only and keeps the functions that build the span
+ * attributes to itself, so the complements below wrap the methods of its
+ * exported `TracingHook` class, which hand over the span and the request body:
+ *
+ * - The built-in tracing always records message content
+ *   (`gen_ai.input.messages` / `gen_ai.output.messages`), ignoring the standard
+ *   `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` switch that
+ *   `weflayr.setup({ captureMessageContent })` drives. Unless capture is
+ *   enabled, the content attributes are removed from the span once the request
+ *   is traced, and never set on it afterwards.
+ * - It forwards the API's raw `finish_reason` ("tool_calls") and the tool call
+ *   `arguments` as the raw JSON string, where the other instrumentors emit the
+ *   OTel GenAI "tool_call" and a parsed arguments object. `gen_ai.output.messages`
+ *   (and `gen_ai.response.finish_reasons`) are rewritten to that shape as they
+ *   are set, so a Mistral tool call normalizes like every other provider's.
+ * - On the request, it records the sampling params, messages and tool
+ *   definitions but not the requested structured-output schema, the
+ *   `reasoning_effort` or the `prompt_cache_key`: they are read off the request
+ *   body (the effort lands on `gen_ai.request.reasoning_effort` and the key on
+ *   `weflayr.cache.key`, as on OpenAI spans). It also misses the embeddings
+ *   input, stamped here as `weflayr.embeddings.input`, the way the other
+ *   embeddings instrumentors do, and records media parts other than images
+ *   under a bare block type with no mime type, which is repaired (see
+ *   `get_input_message_content_telemetry.ts`).
+ * - On the response, it only forwards the flat `prompt_tokens` /
+ *   `completion_tokens` counts, so prompt-cache reads never reach the span:
+ *   `usage.prompt_tokens_details.cached_tokens` is read off the response body
+ *   (or off the streamed chunks as they pass) and stamped as
+ *   `gen_ai.usage.cache_read_input_tokens`.
+ *
+ * Mistral's models on Vertex AI, called through `MistralGCP`, get the same
+ * tracing from `get_vertex_telemetry.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MistralInstrumentor = exports.MISTRAL_TRACING_HOOK_MODULE = exports.MISTRAL_SDK_TELEMETRY_ENV = void 0;
+const node_module_1 = require("node:module");
+const node_url_1 = require("node:url");
+const logger_1 = require("../../logger");
+const span_processor_1 = require("../../otel/span-processor");
+const get_structured_output_schema_telemetry_1 = require("../shared/get_structured_output_schema_telemetry");
+const get_input_message_content_telemetry_1 = require("./get_input_message_content_telemetry");
+const get_structured_output_schema_telemetry_2 = require("./get_structured_output_schema_telemetry");
+const get_vertex_telemetry_1 = require("./get_vertex_telemetry");
+exports.MISTRAL_SDK_TELEMETRY_ENV = 'MISTRAL_SDK_TELEMETRY';
+exports.MISTRAL_TRACING_HOOK_MODULE = '@mistralai/mistralai/hooks/tracing';
+const OTEL_API_PACKAGE = '@opentelemetry/api';
+const CACHE_KEY_ATTR = 'weflayr.cache.key';
+const REASONING_EFFORT_ATTR = 'gen_ai.request.reasoning_effort';
+const EMBEDDINGS_INPUT_ATTR = 'weflayr.embeddings.input';
+const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
+const OUTPUT_MESSAGES_ATTR = 'gen_ai.output.messages';
+const FINISH_REASONS_ATTR = 'gen_ai.response.finish_reasons';
+// Mistral's API vocabulary to the OTel GenAI finish reason (the value the
+// OpenAI/Anthropic instrumentors emit); any other value passes through unchanged.
+const OTEL_FINISH_REASON_BY_MISTRAL_FINISH_REASON = {
+    tool_calls: 'tool_call',
+};
+const MESSAGE_CONTENT_ATTRIBUTES = [
+    'gen_ai.input.messages',
+    'gen_ai.output.messages',
+    'gen_ai.system_instructions',
+    'gen_ai.tool.definitions',
+    'gen_ai.request.structured_output_schema',
+];
+const SERVER_SENT_EVENT_DATA_PREFIX = 'data:';
+function toOtelFinishReason(finishReason) {
+    return typeof finishReason === 'string'
+        ? (OTEL_FINISH_REASON_BY_MISTRAL_FINISH_REASON[finishReason] ?? finishReason)
+        : finishReason;
+}
+/** The tool call arguments as an object when they are a JSON string; a string
+ * the model did not close as valid JSON is kept as is rather than lost. */
+function parseToolCallArguments(toolCallArguments) {
+    if (typeof toolCallArguments !== 'string')
+        return toolCallArguments;
+    try {
+        return JSON.parse(toolCallArguments);
+    }
+    catch {
+        return toolCallArguments;
+    }
+}
+/**
+ * `gen_ai.output.messages` with "tool_calls" finish reasons renamed to
+ * "tool_call" and tool call arguments parsed from Mistral's JSON string.
+ *
+ * Example: `[{"role": "assistant", "parts": [{"type": "tool_call", "name":
+ * "get_weather", "arguments": "{\"city\": \"Paris\"}"}], "finish_reason":
+ * "tool_calls"}]` becomes `[{"role": "assistant", "parts": [{"type":
+ * "tool_call", "name": "get_weather", "arguments": {"city": "Paris"}}],
+ * "finish_reason": "tool_call"}]`.
+ */
+function toOtelOutputMessages(outputMessagesJson) {
+    const messages = JSON.parse(outputMessagesJson);
+    for (const message of messages) {
+        if ('finish_reason' in message) {
+            message.finish_reason = toOtelFinishReason(message.finish_reason);
+        }
+        for (const part of message.parts || []) {
+            if (part.type === 'tool_call' && 'arguments' in part) {
+                part.arguments = parseToolCallArguments(part.arguments);
+            }
+        }
+    }
+    return JSON.stringify(messages);
+}
+function contentCaptureEnabled() {
+    // Read at span time (not instrument time) so a later `weflayr.setup()`
+    // toggling captureMessageContent takes effect. Defaults to off, matching the
+    // OTel GenAI convention for this variable.
+    return (process.env[span_processor_1.CONTENT_CAPTURE_ENV] || '').trim().toLowerCase() === 'true';
+}
+/** Make the span's attribute setter apply the OTel output shape, and drop the
+ * content attributes while capture is disabled. The tracing sets every
+ * attribute it records through it, one key at a time. */
+function shapeAttributesAsTheyAreSet(span) {
+    const originalSetAttribute = span.setAttribute.bind(span);
+    span.setAttribute = (key, value) => {
+        if (!contentCaptureEnabled() && MESSAGE_CONTENT_ATTRIBUTES.includes(key))
+            return span;
+        if (key === OUTPUT_MESSAGES_ATTR && typeof value === 'string') {
+            return originalSetAttribute(key, toOtelOutputMessages(value));
+        }
+        if (key === FINISH_REASONS_ATTR && Array.isArray(value)) {
+            return originalSetAttribute(key, value.map(toOtelFinishReason));
+        }
+        return originalSetAttribute(key, value);
+    };
+}
+/** Remove the content attributes the tracing set while it traced the request,
+ * before the setter above was in place. */
+function dropRequestContentAttributes(span) {
+    if (contentCaptureEnabled())
+        return;
+    const attributes = span.attributes;
+    if (!attributes)
+        return;
+    for (const key of MESSAGE_CONTENT_ATTRIBUTES)
+        delete attributes[key];
+}
+function setRequestBodyTelemetry(span, requestBodyJson) {
+    let requestBody;
+    try {
+        requestBody = JSON.parse(requestBodyJson);
+    }
+    catch {
+        return;
+    }
+    if (typeof requestBody !== 'object' || requestBody === null)
+        return;
+    const body = requestBody;
+    (0, get_structured_output_schema_telemetry_1.setStructuredOutputSchemaTelemetry)(span, (0, get_structured_output_schema_telemetry_2.extractStructuredOutputSchema)(body));
+    (0, get_input_message_content_telemetry_1.setInputMessageContentTelemetry)(span, body);
+    if (body.reasoning_effort)
+        span.setAttribute(REASONING_EFFORT_ATTR, String(body.reasoning_effort));
+    if (body.prompt_cache_key)
+        span.setAttribute(CACHE_KEY_ATTR, String(body.prompt_cache_key));
+    // The embeddings request's `input` is one text or a list of texts; the
+    // weflayr span processor strips it when content capture is off.
+    const embeddedTexts = typeof body.input === 'string' ? [body.input] : body.input;
+    if (Array.isArray(embeddedTexts) && embeddedTexts.length > 0) {
+        span.setAttribute(EMBEDDINGS_INPUT_ATTR, JSON.stringify(embeddedTexts));
+    }
+}
+function setCacheReadTokens(span, responseData) {
+    const usage = responseData?.usage;
+    const cachedTokens = usage?.prompt_tokens_details?.cached_tokens;
+    if (cachedTokens)
+        span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, cachedTokens);
+}
+/**
+ * The streamed response, unchanged, with every chunk's usage read as it
+ * passes: the tracing hook reads the same stream, and ends the span only once
+ * it is exhausted, so the cache-read count is on the span by then.
+ */
+function readCachedTokensFromStream(span, response) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let unfinishedLine = '';
+    const readLines = (text) => {
+        const lines = (unfinishedLine + text).split('\n');
+        unfinishedLine = lines.pop() ?? '';
+        for (const line of lines) {
+            const data = line.trim();
+            if (!data.startsWith(SERVER_SENT_EVENT_DATA_PREFIX))
+                continue;
+            try {
+                setCacheReadTokens(span, JSON.parse(data.slice(SERVER_SENT_EVENT_DATA_PREFIX.length)));
+            }
+            catch {
+                // "[DONE]" and any line that is not a JSON chunk carry no usage.
+            }
+        }
+    };
+    const observedBody = new ReadableStream({
+        async pull(controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    readLines(decoder.decode() + '\n');
+                    controller.close();
+                    return;
+                }
+                readLines(decoder.decode(value, { stream: true }));
+                controller.enqueue(value);
+            }
+            catch (err) {
+                controller.error(err);
+            }
+        },
+        async cancel(reason) {
+            await reader.cancel(reason);
+        },
+    }, { highWaterMark: 0 });
+    return new Response(observedBody, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+async function observeCachedTokens(span, response) {
+    if (!span?.isRecording() || response.bodyUsed)
+        return response;
+    const contentType = (response.headers.get('content-type') || '').toLowerCase();
+    if (contentType.includes('text/event-stream') && response.body) {
+        return readCachedTokensFromStream(span, response);
+    }
+    if (contentType.includes('json')) {
+        setCacheReadTokens(span, await response.clone().json());
+    }
+    return response;
+}
+/**
+ * Load an ESM-only package, found the way `require` finds a package: from the
+ * app's node_modules and NODE_PATH, which a bare `import()` from this file
+ * would not search. It resolves to the same file the app's own import of the
+ * package loads, so both share one module, and so one `TracingHook` class.
+ */
+function loadEsmModule(specifier) {
+    return import((0, node_url_1.pathToFileURL)(require.resolve(specifier)).href);
+}
+/**
+ * Whether the Mistral SDK can load `@opentelemetry/api`, an optional peer
+ * dependency it resolves from its own install location: without it, its
+ * tracing does nothing and says nothing. Installed next to weflayr, which
+ * depends on it, it is usually found there, but not in every layout (pnpm, a
+ * weflayr installed apart from the app).
+ */
+function canTheMistralSdkLoadTheOtelApi() {
+    try {
+        (0, node_module_1.createRequire)(require.resolve(exports.MISTRAL_TRACING_HOOK_MODULE)).resolve(OTEL_API_PACKAGE);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+class MistralInstrumentor {
+    loadModule;
+    canTheSdkLoadTheOtelApi;
+    // The instance that patched the Mistral SDK, undefined while it is unpatched:
+    // autoInstrument builds a new instance on every call, and patching twice
+    // would record every Vertex call twice.
+    static activeInstance;
+    _tracingHookClass;
+    _originalBeforeRequest;
+    _originalAfterSuccess;
+    _ownsTelemetryEnv = false;
+    _vertexInstrumentor;
+    constructor(loadModule = loadEsmModule, canTheSdkLoadTheOtelApi = canTheMistralSdkLoadTheOtelApi) {
+        this.loadModule = loadModule;
+        this.canTheSdkLoadTheOtelApi = canTheSdkLoadTheOtelApi;
+        this._vertexInstrumentor = new get_vertex_telemetry_1.MistralVertexInstrumentor(loadModule);
+    }
+    async instrument() {
+        let tracingModule;
+        try {
+            tracingModule = await this.loadModule(exports.MISTRAL_TRACING_HOOK_MODULE);
+        }
+        catch (err) {
+            throw new Error('weflayr.autoInstrument(MISTRAL): the @mistralai/mistralai client is not installed. ' +
+                'Install it with: npm install @mistralai/mistralai\n' +
+                `Underlying error: ${err?.message || err}`);
+        }
+        if (!this.canTheSdkLoadTheOtelApi()) {
+            throw new Error('weflayr.autoInstrument(MISTRAL): @mistralai/mistralai cannot load @opentelemetry/api, ' +
+                'so its tracing would record nothing. Install it next to it with: npm install @opentelemetry/api');
+        }
+        if (MistralInstrumentor.activeInstance)
+            return;
+        // "global" routes the SDK's spans to the global TracerProvider (the one
+        // weflayr.setup() installed). Any explicit user choice is kept.
+        if (!(exports.MISTRAL_SDK_TELEMETRY_ENV in process.env)) {
+            process.env[exports.MISTRAL_SDK_TELEMETRY_ENV] = 'global';
+            this._ownsTelemetryEnv = true;
+        }
+        const { TracingHook, TRACING_SPAN_KEY, TRACING_BODY_KEY } = tracingModule;
+        const originalBeforeRequest = TracingHook.prototype.beforeRequest;
+        const originalAfterSuccess = TracingHook.prototype.afterSuccess;
+        TracingHook.prototype.beforeRequest = async function beforeRequestWithWeflayrComplements(hookContext, request) {
+            const tracedRequest = await originalBeforeRequest.call(this, hookContext, request);
+            // Never break the user's Mistral call over an enrichment failure.
+            try {
+                const span = hookContext?.[TRACING_SPAN_KEY];
+                if (span?.isRecording()) {
+                    dropRequestContentAttributes(span);
+                    const requestBodyJson = hookContext[TRACING_BODY_KEY];
+                    if (requestBodyJson)
+                        setRequestBodyTelemetry(span, requestBodyJson);
+                    // After the request complements: the content filter applies to what
+                    // the tracing sets, as the response comes in.
+                    shapeAttributesAsTheyAreSet(span);
+                }
+            }
+            catch (err) {
+                (0, logger_1.debug)('mistral: request complements not stamped: %s', err?.message || err);
+            }
+            return tracedRequest;
+        };
+        TracingHook.prototype.afterSuccess = async function afterSuccessWithCacheReadTokens(hookContext, response) {
+            let observedResponse = response;
+            try {
+                observedResponse = await observeCachedTokens(hookContext?.[TRACING_SPAN_KEY], response);
+            }
+            catch (err) {
+                (0, logger_1.debug)('mistral: cache-read tokens not stamped: %s', err?.message || err);
+            }
+            return originalAfterSuccess.call(this, hookContext, observedResponse);
+        };
+        this._tracingHookClass = TracingHook;
+        this._originalBeforeRequest = originalBeforeRequest;
+        this._originalAfterSuccess = originalAfterSuccess;
+        await this._vertexInstrumentor.instrument(tracingModule);
+        MistralInstrumentor.activeInstance = this;
+    }
+    uninstrument() {
+        if (!this._tracingHookClass)
+            return;
+        this._tracingHookClass.prototype.beforeRequest = this._originalBeforeRequest;
+        this._tracingHookClass.prototype.afterSuccess = this._originalAfterSuccess;
+        this._tracingHookClass = undefined;
+        this._originalBeforeRequest = undefined;
+        this._originalAfterSuccess = undefined;
+        this._vertexInstrumentor.uninstrument();
+        MistralInstrumentor.activeInstance = undefined;
+        if (this._ownsTelemetryEnv) {
+            delete process.env[exports.MISTRAL_SDK_TELEMETRY_ENV];
+            this._ownsTelemetryEnv = false;
+        }
+    }
+}
+exports.MistralInstrumentor = MistralInstrumentor;

package/dist/src/instrumentation/mistral/get_input_message_content_telemetry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Media parts of the input messages on Mistral chat spans.
+ *
+ * The SDK's built-in tracing shapes exactly two kinds of content block: text,
+ * and `image_url`, which it records as a `uri` part. Every other block reaches
+ * `gen_ai.input.messages` as a bare `{"type": "<block type>"}` (the fallback
+ * branch of its `formatting.ts`), so a PDF sent as `document_url` is stored
+ * under a name with no mime type, where every other provider stores the
+ * byte-less `{"type": "blob", "mime_type": "application/pdf"}`.
+ *
+ * The mime type it lacks is in the request the caller sent: the block's url is
+ * a `data:` URI holding the bytes. This complement walks the parts the tracing
+ * just stamped alongside the request's blocks and replaces those nameless parts
+ * with the same stub the other providers produce. Blocks the tracing did shape,
+ * and blocks whose url points at a hosted file rather than at inline bytes, are
+ * left alone.
+ */
+import type { Span } from '@opentelemetry/api';
+export declare const INPUT_MESSAGES_ATTRIBUTE = "gen_ai.input.messages";
+/**
+ * `gen_ai.input.messages` with every nameless media part replaced by its blob
+ * stub, or null when there was nothing to repair (the tracing's own JSON is
+ * then left untouched).
+ *
+ * A message's content blocks map one-to-one onto its parts, in order, which is
+ * what lets the repair walk them in step.
+ */
+export declare function repairMediaInputParts(inputMessagesJson: unknown, requestMessages: unknown): string | null;
+/**
+ * Re-stamp `gen_ai.input.messages` when the request carries inline media.
+ *
+ * Only ever rewrites an attribute the tracing already set, so it never adds
+ * message content the tracing did not record.
+ */
+export declare function setInputMessageContentTelemetry(span: Span, requestBody: Record<string, unknown>): void;