weflayr 0.30.0 → 0.31.0

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_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/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_streamed_reasoning_telemetry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The reasoning of a streamed Mistral answer.
+ *
+ * A non-streamed answer of a model that thinks holds its reasoning as a
+ * `thinking` content block before its text, which the `@mistralai/mistralai`
+ * built-in tracing writes as a `reasoning` output part. On a stream the same
+ * blocks arrive in the deltas' `content`, but the tracing's
+ * `accumulateChunksToResponseDict` keeps only their `text` blocks, so a streamed
+ * thinking call records no reasoning part. The package is ESM only, so that
+ * function cannot be wrapped: the thinking is read off the chunks as they pass
+ * (`addStreamedThinking`), then written as a `reasoning` part before the text of
+ * its choice's output message when the tracing sets `gen_ai.output.messages`
+ * (`addStreamedThinkingToOutputMessages`), the part a non-streamed answer gets.
+ */
+/**
+ * Add the thinking text each choice of one streamed chunk (the parsed JSON of
+ * its `data:` line) carries to `thinkingByChoice`, by choice index. Every
+ * choice the chunk names gets an entry, an empty text when it streamed no
+ * thinking, so the entries list the choices the output messages are written
+ * for.
+ *
+ * Example: a chunk whose choice 0 delta content is `[{ type: "thinking",
+ * thinking: [{ type: "text", text: "the r." }] }]` turns `{ 0: "Count " }` into
+ * `{ 0: "Count the r." }`.
+ */
+export declare function addStreamedThinking(chunk: any, thinkingByChoice: Map<number, string>): void;
+/**
+ * `gen_ai.output.messages`, one message per choice in the order of their
+ * index, with each choice's streamed thinking written as a `reasoning` part
+ * before its other parts. A message that already has a reasoning part is left
+ * as it is.
+ *
+ * Example: `[{"role": "assistant", "parts": [{"type": "text", "content": "6"}]}]`
+ * with `{ 0: "Count the r." }` becomes `[{"role": "assistant", "parts":
+ * [{"type": "reasoning", "content": "Count the r."}, {"type": "text", "content":
+ * "6"}]}]`.
+ */
+export declare function addStreamedThinkingToOutputMessages(outputMessagesJson: string, thinkingByChoice: Map<number, string>): string;

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

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * The reasoning of a streamed Mistral answer.
+ *
+ * A non-streamed answer of a model that thinks holds its reasoning as a
+ * `thinking` content block before its text, which the `@mistralai/mistralai`
+ * built-in tracing writes as a `reasoning` output part. On a stream the same
+ * blocks arrive in the deltas' `content`, but the tracing's
+ * `accumulateChunksToResponseDict` keeps only their `text` blocks, so a streamed
+ * thinking call records no reasoning part. The package is ESM only, so that
+ * function cannot be wrapped: the thinking is read off the chunks as they pass
+ * (`addStreamedThinking`), then written as a `reasoning` part before the text of
+ * its choice's output message when the tracing sets `gen_ai.output.messages`
+ * (`addStreamedThinkingToOutputMessages`), the part a non-streamed answer gets.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addStreamedThinking = addStreamedThinking;
+exports.addStreamedThinkingToOutputMessages = addStreamedThinkingToOutputMessages;
+const THINKING_BLOCK_TYPE = 'thinking';
+const REASONING_PART_TYPE = 'reasoning';
+/**
+ * Add the thinking text each choice of one streamed chunk (the parsed JSON of
+ * its `data:` line) carries to `thinkingByChoice`, by choice index. Every
+ * choice the chunk names gets an entry, an empty text when it streamed no
+ * thinking, so the entries list the choices the output messages are written
+ * for.
+ *
+ * Example: a chunk whose choice 0 delta content is `[{ type: "thinking",
+ * thinking: [{ type: "text", text: "the r." }] }]` turns `{ 0: "Count " }` into
+ * `{ 0: "Count the r." }`.
+ */
+function addStreamedThinking(chunk, thinkingByChoice) {
+    for (const choice of chunk?.choices ?? []) {
+        const choiceIndex = choice?.index ?? 0;
+        let thinking = thinkingByChoice.get(choiceIndex) ?? '';
+        const content = choice?.delta?.content;
+        for (const block of Array.isArray(content) ? content : []) {
+            if (block?.type !== THINKING_BLOCK_TYPE || !Array.isArray(block.thinking))
+                continue;
+            for (const piece of block.thinking) {
+                if (typeof piece?.text === 'string')
+                    thinking += piece.text;
+            }
+        }
+        thinkingByChoice.set(choiceIndex, thinking);
+    }
+}
+/**
+ * `gen_ai.output.messages`, one message per choice in the order of their
+ * index, with each choice's streamed thinking written as a `reasoning` part
+ * before its other parts. A message that already has a reasoning part is left
+ * as it is.
+ *
+ * Example: `[{"role": "assistant", "parts": [{"type": "text", "content": "6"}]}]`
+ * with `{ 0: "Count the r." }` becomes `[{"role": "assistant", "parts":
+ * [{"type": "reasoning", "content": "Count the r."}, {"type": "text", "content":
+ * "6"}]}]`.
+ */
+function addStreamedThinkingToOutputMessages(outputMessagesJson, thinkingByChoice) {
+    if (![...thinkingByChoice.values()].some(Boolean))
+        return outputMessagesJson;
+    const messages = JSON.parse(outputMessagesJson);
+    const choiceIndexes = [...thinkingByChoice.keys()].sort((first, second) => first - second);
+    messages.forEach((message, position) => {
+        const thinking = thinkingByChoice.get(choiceIndexes[position]);
+        const parts = Array.isArray(message.parts) ? message.parts : [];
+        if (!thinking || parts.some((part) => part?.type === REASONING_PART_TYPE))
+            return;
+        message.parts = [{ type: REASONING_PART_TYPE, content: thinking }, ...parts];
+    });
+    return JSON.stringify(messages);
+}

package/dist/src/instrumentation/openai/get_streaming_usage.d.ts

@@ -6,8 +6,11 @@
  * final usage chunk OpenAI sends when the request sets
  * `stream_options: { include_usage: true }`. Non-streaming calls work because
  * OpenAI returns `usage` in the response body, which the instrumentor reads
- * directly. The Python OpenLLMetry instrumentor reads the streamed usage, so
- * this gap is Node-only.
+ * directly. The Python OpenLLMetry instrumentor reads the streamed usage but
+ * for its reasoning-token count, which the Python SDK's own
+ * `get_streaming_usage.py` stamps. The chunk's reasoning-token count
+ * (`usage.completion_tokens_details.reasoning_tokens`) is stamped too, as the
+ * non-streamed path's `get_cache_and_reasoning_telemetry.ts` stamps it.
  *
  * It wraps the instrumentor instance's `_streamingWrapPromise`: that handler
  * hands us the span and ends it only after its chunk loop, so when the usage

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

@@ -7,8 +7,11 @@
  * final usage chunk OpenAI sends when the request sets
  * `stream_options: { include_usage: true }`. Non-streaming calls work because
  * OpenAI returns `usage` in the response body, which the instrumentor reads
- * directly. The Python OpenLLMetry instrumentor reads the streamed usage, so
- * this gap is Node-only.
+ * directly. The Python OpenLLMetry instrumentor reads the streamed usage but
+ * for its reasoning-token count, which the Python SDK's own
+ * `get_streaming_usage.py` stamps. The chunk's reasoning-token count
+ * (`usage.completion_tokens_details.reasoning_tokens`) is stamped too, as the
+ * non-streamed path's `get_cache_and_reasoning_telemetry.ts` stamps it.
  *
  * It wraps the instrumentor instance's `_streamingWrapPromise`: that handler
  * hands us the span and ends it only after its chunk loop, so when the usage
@@ -21,6 +24,7 @@ const USAGE_INPUT_TOKENS_ATTR = 'gen_ai.usage.input_tokens';
 const USAGE_OUTPUT_TOKENS_ATTR = 'gen_ai.usage.output_tokens';
 const USAGE_TOTAL_TOKENS_ATTR = 'gen_ai.usage.total_tokens';
 const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
+const REASONING_TOKENS_ATTR = 'gen_ai.usage.reasoning_tokens';
 function _setUsageAttributes(span, usage) {
     if (typeof usage.prompt_tokens === 'number') {
         span.setAttribute(USAGE_INPUT_TOKENS_ATTR, usage.prompt_tokens);
@@ -37,6 +41,10 @@ function _setUsageAttributes(span, usage) {
     if (cachedTokens) {
         span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, cachedTokens);
     }
+    const reasoningTokens = usage.completion_tokens_details && usage.completion_tokens_details.reasoning_tokens;
+    if (reasoningTokens) {
+        span.setAttribute(REASONING_TOKENS_ATTR, reasoningTokens);
+    }
 }
 class OpenAIStreamingUsageInstrumentor {
     // [instrumentation, methodName, originalFunction] for uninstrument().

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

@@ -1,6 +1,6 @@
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import type { ExportResult } from '@opentelemetry/core';
-import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import type { ReadableSpan } from '@opentelemetry/sdk-trace';
 declare const _RETRYABLE_STATUS: Set<number>;
 type ExportFn = (spans: ReadableSpan[], resultCallback: (result: ExportResult) => void) => void;
 export declare function _exportWithRetry(originalExport: ExportFn, { maxRetries, maxRetryMs }: {

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

@@ -1,4 +1,4 @@
-import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import type { ReadableSpan } from '@opentelemetry/sdk-trace';
 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;

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

@@ -1,5 +1,5 @@
 import { type Context, type Span } from '@opentelemetry/api';
-import { type ReadableSpan, type SpanExporter, type SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { type ReadableSpan, type SpanExporter, type SpanProcessor } from '@opentelemetry/sdk-trace';
 export declare const CONTENT_CAPTURE_ENV = "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT";
 /** Arbitrary key-value tags applied to OTel spans. */
 export type Tags = Record<string, string | number | boolean>;

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

@@ -17,7 +17,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WeflayrSpanProcessor = exports.CONTENT_CAPTURE_ENV = void 0;
 const api_1 = require("@opentelemetry/api");
-const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const sdk_trace_1 = require("@opentelemetry/sdk-trace");
 const propagation_1 = require("./propagation");
 const span_filter_1 = require("./span-filter");
 const logger_1 = require("../logger");
@@ -73,8 +73,8 @@ class WeflayrSpanProcessor {
         }
         this._delegate =
             exportMode === 'immediate'
-                ? new sdk_trace_base_1.SimpleSpanProcessor(exporter)
-                : new sdk_trace_base_1.BatchSpanProcessor(exporter);
+                ? new sdk_trace_1.SimpleSpanProcessor({ exporter })
+                : new sdk_trace_1.BatchSpanProcessor({ exporter });
         this._defaultTags = defaultTags;
         this._mask = mask;
         this._maskFunctionSource = mask ? String(mask) : null;