weflayr 0.29.1 → 0.31.0

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

@@ -15,3 +15,11 @@
  * `"https://example.com/cat.png"` -> `null`.
  */
 export declare function getDataUriMimeType(uri: string): string | null;
+/**
+ * The `blob` part holding the bytes of a base64 `data:` URI, or null when the
+ * string is not one. The ingestion API moves the bytes to S3.
+ *
+ * e.g. `"data:image/png;base64,AAA"` ->
+ * `{ type: "blob", mime_type: "image/png", content: "AAA" }`.
+ */
+export declare function getDataUriBlobPart(uri: string): Record<string, string> | null;

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

@@ -10,6 +10,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDataUriMimeType = getDataUriMimeType;
+exports.getDataUriBlobPart = getDataUriBlobPart;
 const DATA_URI_PREFIX = 'data:';
 /**
  * The mime type of a `data:<mime_type>[;base64],<payload>` URI, or null when
@@ -23,3 +24,20 @@ function getDataUriMimeType(uri) {
         return null;
     return uri.slice(DATA_URI_PREFIX.length).split(';')[0].split(',')[0];
 }
+/**
+ * The `blob` part holding the bytes of a base64 `data:` URI, or null when the
+ * string is not one. The ingestion API moves the bytes to S3.
+ *
+ * e.g. `"data:image/png;base64,AAA"` ->
+ * `{ type: "blob", mime_type: "image/png", content: "AAA" }`.
+ */
+function getDataUriBlobPart(uri) {
+    const mimeType = getDataUriMimeType(uri);
+    const separatorIndex = uri.indexOf(',');
+    if (mimeType === null ||
+        separatorIndex === -1 ||
+        !uri.slice(0, separatorIndex).endsWith(';base64')) {
+        return null;
+    }
+    return { type: 'blob', mime_type: mimeType, content: uri.slice(separatorIndex + 1) };
+}

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

@@ -2,20 +2,22 @@
  * Streamed-accumulation gap filling for the Anthropic chat span.
  *
  * `@traceloop/instrumentation-anthropic` accumulates a streamed response into a
- * result object but drops two things on the way:
+ * result object but drops three things on the way:
  *   - the `message_delta` chunk's `delta.stop_reason`, so streamed spans format
- *     their output message with an empty `finish_reason`, and
+ *     their output message with an empty `finish_reason`,
  *   - the `content_block_delta` chunks' `input_json_delta` fragments, so a
  *     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.
+ *     provider-run web search, whose query streams the same way, and
+ *   - the `content_block_delta` chunks' `thinking_delta` text, so a streamed
+ *     thinking block's `reasoning` part is empty.
  *
  * `_streamingWrapPromise(client, moduleExports, { span, type, promise })`
  * returns `new moduleExports.APIPromise(...)` whose parse step wraps the real
  * SDK stream with the instrumentor's accumulating iterator. This complement
  * hands it a patched `moduleExports` whose APIPromise interposes on that parse
  * step, observing the chunks (outside the accumulating iterator, so every chunk
- * is seen before the iterator finishes) to capture both — which are then
+ * is seen before the iterator finishes) to capture them, which are then
  * injected into the accumulated result just before `_endSpan` formats the
  * output message.
  */

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

@@ -3,20 +3,22 @@
  * Streamed-accumulation gap filling for the Anthropic chat span.
  *
  * `@traceloop/instrumentation-anthropic` accumulates a streamed response into a
- * result object but drops two things on the way:
+ * result object but drops three things on the way:
  *   - the `message_delta` chunk's `delta.stop_reason`, so streamed spans format
- *     their output message with an empty `finish_reason`, and
+ *     their output message with an empty `finish_reason`,
  *   - the `content_block_delta` chunks' `input_json_delta` fragments, so a
  *     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.
+ *     provider-run web search, whose query streams the same way, and
+ *   - the `content_block_delta` chunks' `thinking_delta` text, so a streamed
+ *     thinking block's `reasoning` part is empty.
  *
  * `_streamingWrapPromise(client, moduleExports, { span, type, promise })`
  * returns `new moduleExports.APIPromise(...)` whose parse step wraps the real
  * SDK stream with the instrumentor's accumulating iterator. This complement
  * hands it a patched `moduleExports` whose APIPromise interposes on that parse
  * step, observing the chunks (outside the accumulating iterator, so every chunk
- * is seen before the iterator finishes) to capture both — which are then
+ * is seen before the iterator finishes) to capture them, which are then
  * injected into the accumulated result just before `_endSpan` formats the
  * output message.
  */
@@ -36,7 +38,7 @@ class AnthropicStreamingAccumulationInstrumentor {
         function gapsFor(span) {
             let gaps = gapsBySpan.get(span);
             if (!gaps) {
-                gaps = { toolArgumentsJsonByIndex: new Map() };
+                gaps = { toolArgumentsJsonByIndex: new Map(), thinkingByIndex: new Map() };
                 gapsBySpan.set(span, gaps);
             }
             return gaps;
@@ -58,6 +60,14 @@ class AnthropicStreamingAccumulationInstrumentor {
                         const argumentsByIndex = gapsFor(span).toolArgumentsJsonByIndex;
                         argumentsByIndex.set(chunk.index, (argumentsByIndex.get(chunk.index) ?? '') + chunk.delta.partial_json);
                     }
+                    if (chunk &&
+                        chunk.type === 'content_block_delta' &&
+                        chunk.delta &&
+                        chunk.delta.type === 'thinking_delta' &&
+                        typeof chunk.delta.thinking === 'string') {
+                        const thinkingByIndex = gapsFor(span).thinkingByIndex;
+                        thinkingByIndex.set(chunk.index, (thinkingByIndex.get(chunk.index) ?? '') + chunk.delta.thinking);
+                    }
                 }
                 catch {
                     // Never break the caller's stream over an enrichment failure.
@@ -124,6 +134,13 @@ class AnthropicStreamingAccumulationInstrumentor {
                                 }
                             }
                         }
+                        for (const [index, thinking] of gaps.thinkingByIndex) {
+                            const block = Array.isArray(args.result.content) && args.result.content[index];
+                            // Only fill the gap, as for the tool arguments above.
+                            if (block && block.type === 'thinking' && !block.thinking) {
+                                block.thinking = thinking;
+                            }
+                        }
                     }
                 }
                 catch {

package/dist/src/instrumentation/bedrock/{get_cache_telemetry.d.ts → get_cache_and_reasoning_telemetry.d.ts}

@@ -14,6 +14,13 @@
  * It wraps the instrumentor instance's `_wrapPromise(span, promise, modelId)`,
  * which resolves the send promise and enriches the span before ending it,
  * letting us read the decoded body off the same response while the span is open.
+ *
+ * Claude on Bedrock also reports its extended-thinking count, a part of
+ * `output_tokens`, as `usage.output_tokens_details.thinking_tokens` in the
+ * response body, and in the closing `message_delta` chunk of a stream. The
+ * instrumentor drops it, so it is stamped as
+ * `gen_ai.usage.output_tokens_details.thinking_tokens`, the key the Anthropic
+ * complement stamps, matching the Python SDK.
  */
 export declare class BedrockPromptCachingInstrumentor {
     private _patched;

package/dist/src/instrumentation/bedrock/{get_cache_telemetry.js → get_cache_and_reasoning_telemetry.js}

@@ -15,11 +15,19 @@
  * It wraps the instrumentor instance's `_wrapPromise(span, promise, modelId)`,
  * which resolves the send promise and enriches the span before ending it,
  * letting us read the decoded body off the same response while the span is open.
+ *
+ * Claude on Bedrock also reports its extended-thinking count, a part of
+ * `output_tokens`, as `usage.output_tokens_details.thinking_tokens` in the
+ * response body, and in the closing `message_delta` chunk of a stream. The
+ * instrumentor drops it, so it is stamped as
+ * `gen_ai.usage.output_tokens_details.thinking_tokens`, the key the Anthropic
+ * complement stamps, matching the Python SDK.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BedrockPromptCachingInstrumentor = void 0;
 const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
 const CACHE_CREATION_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_creation_input_tokens';
+const THINKING_TOKENS_ATTR = 'gen_ai.usage.output_tokens_details.thinking_tokens';
 // Stamp cache counts from a `usage` object onto the span: Nova's camelCase
 // count fields, or Anthropic-on-Bedrock's native snake_case ones.
 function _setCacheFromUsage(span, usage) {
@@ -34,6 +42,15 @@ function _setCacheFromUsage(span, usage) {
         span.setAttribute(CACHE_CREATION_INPUT_TOKENS_ATTR, write);
     }
 }
+// Stamp Claude's thinking count from a `usage` object onto the span.
+function _setThinkingFromUsage(span, usage) {
+    if (!usage || !span || !span.isRecording || !span.isRecording())
+        return;
+    const thinking = usage.output_tokens_details?.thinking_tokens;
+    if (typeof thinking === 'number' && thinking) {
+        span.setAttribute(THINKING_TOKENS_ATTR, thinking);
+    }
+}
 function _setCacheTokens(span, response) {
     if (!span || !span.isRecording || !span.isRecording())
         return;
@@ -45,7 +62,9 @@ function _setCacheTokens(span, response) {
     if (!body || typeof body[Symbol.asyncIterator] === 'function')
         return;
     try {
-        _setCacheFromUsage(span, JSON.parse(new TextDecoder().decode(body)).usage);
+        const usage = JSON.parse(new TextDecoder().decode(body)).usage;
+        _setCacheFromUsage(span, usage);
+        _setThinkingFromUsage(span, usage);
     }
     catch {
         // Never break span enrichment over a parse failure.
@@ -77,7 +96,8 @@ class BedrockPromptCachingInstrumentor {
         // Streamed: the instrumentor hands every chunk to
         // `_handleNovaStreamingMetadata(span, parsedResponse)` but never reads its
         // cache counts: Nova's arrive in the trailing `metadata` chunk, Anthropic's
-        // in the opening `message_start` one.
+        // in the opening `message_start` one. Claude's thinking count arrives in its
+        // closing `message_delta` one.
         const metadataOriginal = instrumentation._handleNovaStreamingMetadata;
         if (typeof metadataOriginal === 'function') {
             instrumentation._handleNovaStreamingMetadata = function handleMetadataWithCache(span, parsedResponse) {
@@ -86,6 +106,9 @@ class BedrockPromptCachingInstrumentor {
                         ? parsedResponse.message?.usage
                         : parsedResponse?.metadata?.usage;
                     _setCacheFromUsage(span, usage);
+                    if (parsedResponse?.type === 'message_delta') {
+                        _setThinkingFromUsage(span, parsedResponse.usage);
+                    }
                 }
                 catch {
                     // Never break the caller's stream over an enrichment failure.

package/dist/src/instrumentation/bedrock/get_input_message_content_telemetry.js

@@ -12,24 +12,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BedrockInputMessageContentInstrumentor = void 0;
 const _MEDIA_BLOCK_TYPES = ['image', 'document', 'video', 'audio'];
-// A byte-less stub for a media content block, null when the block is not media.
-// Anthropic-on-Bedrock names the media under `type` and carries its mime type in
-// `source.media_type`; Nova puts the media under its own key
-// (`{"image": {"format": "png", "source": {...}}}`) and states no mime type.
-function _getMediaStubPart(block) {
+function _buildBlobPart(mimeType, base64Bytes) {
+    return typeof base64Bytes === 'string'
+        ? { type: 'blob', mime_type: mimeType, content: base64Bytes }
+        : { type: 'blob', mime_type: mimeType };
+}
+// A blob part holding the bytes of a media content block, null when the block
+// is not media. Anthropic-on-Bedrock names the media under `type` and carries
+// its base64 in `source.data` and its mime type in `source.media_type`; Nova puts
+// the media under its own key
+// (`{"image": {"format": "png", "source": {"bytes": ...}}}`) and states no mime
+// type.
+function _getMediaBlobPart(block) {
     if (_MEDIA_BLOCK_TYPES.includes(block.type)) {
-        const source = block.source;
-        const mediaType = source && typeof source === 'object' ? source.media_type : null;
-        return { type: 'blob', mime_type: String(mediaType || '') };
+        const source = block.source && typeof block.source === 'object' ? block.source : {};
+        return _buildBlobPart(String(source.media_type || ''), source.data);
     }
-    if (_MEDIA_BLOCK_TYPES.some((media) => block[media] && typeof block[media] === 'object')) {
-        return { type: 'blob', mime_type: '' };
+    const novaMedia = _MEDIA_BLOCK_TYPES.find((media) => block[media] && typeof block[media] === 'object');
+    if (novaMedia) {
+        const source = block[novaMedia].source;
+        return _buildBlobPart('', source && typeof source === 'object' ? source.bytes : undefined);
     }
     return null;
 }
-// Text blocks keep their text; media blocks become a byte-less stub, so the
-// payload stays off the span while the analyses reading these messages still see
-// that the call carried content the stored text does not.
+// Text blocks keep their text; media blocks become blob parts holding their
+// bytes.
 function _contentToParts(content) {
     if (typeof content === 'string') {
         return [{ type: 'text', content }];
@@ -44,9 +51,9 @@ function _contentToParts(content) {
             parts.push({ type: 'text', content: block.text });
             continue;
         }
-        const mediaStubPart = _getMediaStubPart(block);
-        if (mediaStubPart !== null)
-            parts.push(mediaStubPart);
+        const mediaBlobPart = _getMediaBlobPart(block);
+        if (mediaBlobPart !== null)
+            parts.push(mediaBlobPart);
     }
     return parts;
 }

package/dist/src/instrumentation/bedrock/get_streaming_output_message_telemetry.d.ts

@@ -19,6 +19,12 @@
  * a forced tool call streams into an empty message carrying only
  * `finish_reason: "tool_call"`. Upstream accumulates tool blocks on the Converse
  * API path only, never on InvokeModelWithResponseStream.
+ *
+ * Anthropic's extended thinking streams as `thinking_delta`s, which upstream
+ * drops too, so they are accumulated into a `reasoning` part written before the
+ * text, the part a non-streamed answer gets (see
+ * `get_reasoning_output_telemetry.ts`). A call that only thinks, stopped by its
+ * token cap before any text, otherwise records an empty message.
  */
 export declare class BedrockStreamingOutputMessageInstrumentor {
     private _patched;

package/dist/src/instrumentation/bedrock/get_streaming_output_message_telemetry.js

@@ -20,6 +20,12 @@
  * a forced tool call streams into an empty message carrying only
  * `finish_reason: "tool_call"`. Upstream accumulates tool blocks on the Converse
  * API path only, never on InvokeModelWithResponseStream.
+ *
+ * Anthropic's extended thinking streams as `thinking_delta`s, which upstream
+ * drops too, so they are accumulated into a `reasoning` part written before the
+ * text, the part a non-streamed answer gets (see
+ * `get_reasoning_output_telemetry.ts`). A call that only thinks, stopped by its
+ * token cap before any text, otherwise records an empty message.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BedrockStreamingOutputMessageInstrumentor = void 0;
@@ -58,7 +64,8 @@ function _accumulateToolCall(state, parsedResponse) {
 class BedrockStreamingOutputMessageInstrumentor {
     // [instrumentation, methodName, originalFunction] for uninstrument().
     _patched = [];
-    // span -> {text, stopReason} accumulated across the stream's chunks.
+    // span -> {reasoning, text, stopReason, toolCalls} accumulated across the
+    // stream's chunks.
     _streamStateBySpan = new WeakMap();
     // No-op (and never throws) if the instrumentor's internals have changed shape —
     // the worst case is an empty streamed output message, never a crash.
@@ -72,6 +79,7 @@ class BedrockStreamingOutputMessageInstrumentor {
         instrumentation._handleNovaStreamingMetadata = function handleWithOutputMessage(span, parsedResponse) {
             try {
                 const state = streamStateBySpan.get(span) || {
+                    reasoning: '',
                     text: '',
                     stopReason: null,
                     toolCalls: [],
@@ -80,6 +88,12 @@ class BedrockStreamingOutputMessageInstrumentor {
                     (parsedResponse?.type === 'content_block_delta' ? parsedResponse.delta?.text : undefined);
                 if (typeof delta === 'string')
                     state.text += delta;
+                const thinkingDelta = parsedResponse?.type === 'content_block_delta' &&
+                    parsedResponse.delta?.type === 'thinking_delta'
+                    ? parsedResponse.delta.thinking
+                    : undefined;
+                if (typeof thinkingDelta === 'string')
+                    state.reasoning += thinkingDelta;
                 const stopReason = parsedResponse?.messageStop?.stopReason ??
                     (parsedResponse?.type === 'message_delta'
                         ? parsedResponse.delta?.stop_reason
@@ -89,8 +103,10 @@ class BedrockStreamingOutputMessageInstrumentor {
                 _accumulateToolCall(state, parsedResponse);
                 streamStateBySpan.set(span, state);
                 const isLastChunk = parsedResponse?.metadata || parsedResponse?.type === 'message_stop';
-                if (isLastChunk && (state.text || state.toolCalls.length)) {
+                if (isLastChunk && (state.reasoning || state.text || state.toolCalls.length)) {
                     const parts = [];
+                    if (state.reasoning)
+                        parts.push({ type: 'reasoning', content: state.reasoning });
                     if (state.text)
                         parts.push({ type: 'text', content: state.text });
                     for (const toolCall of state.toolCalls) {

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

@@ -16,7 +16,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BedrockTelemetryInstrumentor = void 0;
 const get_cache_config_telemetry_1 = require("./get_cache_config_telemetry");
-const get_cache_telemetry_1 = require("./get_cache_telemetry");
+const get_cache_and_reasoning_telemetry_1 = require("./get_cache_and_reasoning_telemetry");
 const get_input_message_content_telemetry_1 = require("./get_input_message_content_telemetry");
 const get_streaming_output_message_telemetry_1 = require("./get_streaming_output_message_telemetry");
 const get_model_id_telemetry_1 = require("./get_model_id_telemetry");
@@ -28,7 +28,7 @@ class BedrockTelemetryInstrumentor {
     _subInstrumentors;
     constructor() {
         this._subInstrumentors = [
-            new get_cache_telemetry_1.BedrockPromptCachingInstrumentor(),
+            new get_cache_and_reasoning_telemetry_1.BedrockPromptCachingInstrumentor(),
             new get_cache_config_telemetry_1.BedrockCacheConfigInstrumentor(),
             new get_input_message_content_telemetry_1.BedrockInputMessageContentInstrumentor(),
             new get_streaming_output_message_telemetry_1.BedrockStreamingOutputMessageInstrumentor(),

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

@@ -2,9 +2,8 @@
  * Input message content for Cohere v2 chat spans.
  *
  * Mirror of the Python complement's message shaping: a v2 request's messages in
- * the standard role+parts shape, with media blocks reduced to a byte-less stub
- * so the payload stays off the span while the analyses reading these messages
- * still see that the call carried content the stored text does not.
+ * the standard role+parts shape, with an inline image as a `blob` part holding
+ * its bytes, which the ingestion API moves to S3.
  *
  * Python wraps the OpenLLMetry instrumentor to stamp this (that instrumentor
  * covers v2 but records its messages in a shape OTel rejects). The Node

package/dist/src/instrumentation/cohere/get_input_message_content_telemetry.js

@@ -3,9 +3,8 @@
  * Input message content for Cohere v2 chat spans.
  *
  * Mirror of the Python complement's message shaping: a v2 request's messages in
- * the standard role+parts shape, with media blocks reduced to a byte-less stub
- * so the payload stays off the span while the analyses reading these messages
- * still see that the call carried content the stored text does not.
+ * the standard role+parts shape, with an inline image as a `blob` part holding
+ * its bytes, which the ingestion API moves to S3.
  *
  * Python wraps the OpenLLMetry instrumentor to stamp this (that instrumentor
  * covers v2 but records its messages in a shape OTel rejects). The Node
@@ -22,8 +21,8 @@ function asObject(value) {
         : null;
 }
 /**
- * An image block as a part: an inline data URI keeps its mime type only, a
- * hosted image keeps its url (which is not a payload).
+ * An image block as a part: an inline data URI becomes a blob holding its
+ * bytes, a hosted image keeps its url.
  */
 function getImagePart(block) {
     // The JS client spells the key imageUrl; the wire (and the Python client)
@@ -31,14 +30,11 @@ function getImagePart(block) {
     const rawImageUrl = block.imageUrl ?? block.image_url;
     const imageUrl = asObject(rawImageUrl);
     const url = String((imageUrl ? imageUrl.url : rawImageUrl) ?? '');
-    const mimeType = (0, get_data_uri_mime_type_1.getDataUriMimeType)(url);
-    if (mimeType === null)
-        return { type: 'uri', uri: url };
-    return { type: 'blob', mime_type: mimeType };
+    return (0, get_data_uri_mime_type_1.getDataUriBlobPart)(url) ?? { type: 'uri', uri: url };
 }
 /**
  * A v2 message's `content` as normalized parts. A plain string is one text
- * part; a list keeps its text, turns images into a byte-less stub, and keeps
+ * part; a list keeps its text, turns images into blob parts, and keeps
  * any other block under its own type - naming it is what lets the analyses tell
  * a text-only prompt from one whose content was not stored.
  */

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

@@ -46,9 +46,13 @@ function _contentToMessage(content) {
             parts.push({ type: 'text', content: rawPart.text });
         }
         else if (rawPart && rawPart.inlineData) {
-            // Non-text parts (e.g. audio) become a byte-less blob stub so span
-            // attributes never carry raw media payloads.
-            parts.push({ type: 'blob', mime_type: rawPart.inlineData.mimeType || '' });
+            // Non-text parts (e.g. audio) become a blob part holding the base64
+            // bytes, which the ingestion API moves to S3.
+            parts.push({
+                type: 'blob',
+                mime_type: rawPart.inlineData.mimeType || '',
+                content: rawPart.inlineData.data,
+            });
         }
     }
     return { role, parts };

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

@@ -34,10 +34,16 @@
  *   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`.
+ *   `completion_tokens` counts, so prompt-cache reads and the reasoning count
+ *   never reach the span: `usage.prompt_tokens_details.cached_tokens` and
+ *   `usage.completion_tokens_details.reasoning_tokens` (a part of
+ *   `completion_tokens`) are read off the response body (or off the streamed
+ *   chunks as they pass) and stamped as `gen_ai.usage.cache_read_input_tokens`
+ *   and `gen_ai.usage.output_tokens_details.reasoning_tokens`.
+ * - On a stream, its accumulation of the chunks drops the `thinking` blocks, so
+ *   a streamed thinking call records no reasoning part: the thinking is read off
+ *   the streamed chunks as they pass and added to `gen_ai.output.messages` as it
+ *   is set (see `get_streamed_reasoning_telemetry.ts`).
  *
  * Mistral's models on Vertex AI, called through `MistralGCP`, get the same
  * tracing from `get_vertex_telemetry.ts`.

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

@@ -35,10 +35,16 @@
  *   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`.
+ *   `completion_tokens` counts, so prompt-cache reads and the reasoning count
+ *   never reach the span: `usage.prompt_tokens_details.cached_tokens` and
+ *   `usage.completion_tokens_details.reasoning_tokens` (a part of
+ *   `completion_tokens`) are read off the response body (or off the streamed
+ *   chunks as they pass) and stamped as `gen_ai.usage.cache_read_input_tokens`
+ *   and `gen_ai.usage.output_tokens_details.reasoning_tokens`.
+ * - On a stream, its accumulation of the chunks drops the `thinking` blocks, so
+ *   a streamed thinking call records no reasoning part: the thinking is read off
+ *   the streamed chunks as they pass and added to `gen_ai.output.messages` as it
+ *   is set (see `get_streamed_reasoning_telemetry.ts`).
  *
  * Mistral's models on Vertex AI, called through `MistralGCP`, get the same
  * tracing from `get_vertex_telemetry.ts`.
@@ -51,6 +57,7 @@ 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_streamed_reasoning_telemetry_1 = require("./get_streamed_reasoning_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';
@@ -60,6 +67,7 @@ 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 REASONING_TOKENS_ATTR = 'gen_ai.usage.output_tokens_details.reasoning_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
@@ -116,6 +124,23 @@ function toOtelOutputMessages(outputMessagesJson) {
     }
     return JSON.stringify(messages);
 }
+// Each streamed call's thinking by choice index, read off its chunks as they
+// pass, until the tracing writes its output messages.
+const streamedThinkingBySpan = new WeakMap();
+/** `gen_ai.output.messages` with the call's streamed thinking added; unchanged
+ * for a call that streamed none, or when it cannot be added. */
+function addSpanStreamedThinking(span, outputMessagesJson) {
+    const thinkingByChoice = streamedThinkingBySpan.get(span);
+    if (!thinkingByChoice)
+        return outputMessagesJson;
+    try {
+        return (0, get_streamed_reasoning_telemetry_1.addStreamedThinkingToOutputMessages)(outputMessagesJson, thinkingByChoice);
+    }
+    catch (err) {
+        (0, logger_1.debug)('mistral: streamed thinking not recorded: %s', err?.message || err);
+        return outputMessagesJson;
+    }
+}
 function contentCaptureEnabled() {
     // Read at span time (not instrument time) so a later `weflayr.setup()`
     // toggling captureMessageContent takes effect. Defaults to off, matching the
@@ -131,7 +156,7 @@ function shapeAttributesAsTheyAreSet(span) {
         if (!contentCaptureEnabled() && MESSAGE_CONTENT_ATTRIBUTES.includes(key))
             return span;
         if (key === OUTPUT_MESSAGES_ATTR && typeof value === 'string') {
-            return originalSetAttribute(key, toOtelOutputMessages(value));
+            return originalSetAttribute(key, toOtelOutputMessages(addSpanStreamedThinking(span, value)));
         }
         if (key === FINISH_REASONS_ATTR && Array.isArray(value)) {
             return originalSetAttribute(key, value.map(toOtelFinishReason));
@@ -174,18 +199,24 @@ function setRequestBodyTelemetry(span, requestBodyJson) {
         span.setAttribute(EMBEDDINGS_INPUT_ATTR, JSON.stringify(embeddedTexts));
     }
 }
-function setCacheReadTokens(span, responseData) {
+function setTokenDetails(span, responseData) {
     const usage = responseData?.usage;
     const cachedTokens = usage?.prompt_tokens_details?.cached_tokens;
     if (cachedTokens)
         span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, cachedTokens);
+    const reasoningTokens = usage?.completion_tokens_details?.reasoning_tokens;
+    if (reasoningTokens)
+        span.setAttribute(REASONING_TOKENS_ATTR, reasoningTokens);
 }
 /**
- * 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.
+ * The streamed response, unchanged, with every chunk's usage and thinking read
+ * as it passes: the tracing hook reads the same stream, and ends the span only
+ * once it is exhausted, so the cache-read and reasoning counts are on the span, and the
+ * thinking ready for its output messages, by then.
  */
-function readCachedTokensFromStream(span, response) {
+function readTokenDetailsAndThinkingFromStream(span, response) {
+    const thinkingByChoice = new Map();
+    streamedThinkingBySpan.set(span, thinkingByChoice);
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let unfinishedLine = '';
@@ -197,10 +228,12 @@ function readCachedTokensFromStream(span, response) {
             if (!data.startsWith(SERVER_SENT_EVENT_DATA_PREFIX))
                 continue;
             try {
-                setCacheReadTokens(span, JSON.parse(data.slice(SERVER_SENT_EVENT_DATA_PREFIX.length)));
+                const chunk = JSON.parse(data.slice(SERVER_SENT_EVENT_DATA_PREFIX.length));
+                setTokenDetails(span, chunk);
+                (0, get_streamed_reasoning_telemetry_1.addStreamedThinking)(chunk, thinkingByChoice);
             }
             catch {
-                // "[DONE]" and any line that is not a JSON chunk carry no usage.
+                // "[DONE]" and any line that is not a JSON chunk carry no usage or thinking.
             }
         }
     };
@@ -235,10 +268,10 @@ async function observeCachedTokens(span, response) {
         return response;
     const contentType = (response.headers.get('content-type') || '').toLowerCase();
     if (contentType.includes('text/event-stream') && response.body) {
-        return readCachedTokensFromStream(span, response);
+        return readTokenDetailsAndThinkingFromStream(span, response);
     }
     if (contentType.includes('json')) {
-        setCacheReadTokens(span, await response.clone().json());
+        setTokenDetails(span, await response.clone().json());
     }
     return response;
 }

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

@@ -6,7 +6,7 @@
  * `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"}`.
+ * `{"type": "blob", "mime_type": "application/pdf", "content": <base64>}`.
  *
  * 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

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

@@ -7,7 +7,7 @@
  * `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"}`.
+ * `{"type": "blob", "mime_type": "application/pdf", "content": <base64>}`.
  *
  * 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
@@ -38,20 +38,17 @@ function getBlockUrl(block) {
     return String(url ?? '');
 }
 /**
- * The byte-less part for a content block carrying inline bytes, or null for a
- * block that carries none.
+ * The blob part for a content block carrying inline bytes, or null for a block
+ * that carries none.
  *
  * e.g. `{"type": "document_url", "document_url": "data:application/pdf;base64,AAA"}`
- * -> `{"type": "blob", "mime_type": "application/pdf"}`.
+ * -> `{"type": "blob", "mime_type": "application/pdf", "content": "AAA"}`.
  */
 function getMediaStub(rawBlock) {
     const block = asObject(rawBlock);
     if (block === null)
         return null;
-    const mimeType = (0, get_data_uri_mime_type_1.getDataUriMimeType)(getBlockUrl(block));
-    if (mimeType === null)
-        return null;
-    return { type: 'blob', mime_type: mimeType };
+    return (0, get_data_uri_mime_type_1.getDataUriBlobPart)(getBlockUrl(block));
 }
 /** True for the `{"type": "<block type>"}` the tracing falls back to on a
  * block it does not shape: a type and nothing else. */