weflayr 0.29.1 → 0.31.0

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_file_part_mime_type_telemetry.d.ts

@@ -4,9 +4,10 @@
  * The traceloop instrumentor maps a `file` content block to a blob part but
  * reads its mime type from `block.file.mime_type`, a field OpenAI's API does
  * not have, so every inline document is recorded as
- * `application/octet-stream`. The real mime type is right there in the data URI
- * the caller sent (`data:application/pdf;base64,...`), and the Python SDK keeps
- * it, so this complement reads it back off the request and repairs the part.
+ * `application/octet-stream`. The real mime type and the bytes are right there
+ * in the data URI the caller sent (`data:application/pdf;base64,...`), and the
+ * Python SDK keeps them, so this complement reads them back off the request and
+ * repairs the part.
  *
  * Wraps `startSpan({ type, params })`, which is where the instrumentor builds
  * `gen_ai.input.messages`, so the attribute is already on the span when this
@@ -15,7 +16,7 @@
  */
 /**
  * `gen_ai.input.messages` with every blob part whose request block carried a
- * data URI given that URI's mime type, or null when there was nothing to
+ * data URI given that URI's mime type and bytes, or null when there was nothing to
  * repair (so the instrumentor's own JSON is left untouched).
  */
 export declare function repairFileMimeTypes(inputMessagesJson: unknown, messages: unknown): string | null;

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

@@ -5,9 +5,10 @@
  * The traceloop instrumentor maps a `file` content block to a blob part but
  * reads its mime type from `block.file.mime_type`, a field OpenAI's API does
  * not have, so every inline document is recorded as
- * `application/octet-stream`. The real mime type is right there in the data URI
- * the caller sent (`data:application/pdf;base64,...`), and the Python SDK keeps
- * it, so this complement reads it back off the request and repairs the part.
+ * `application/octet-stream`. The real mime type and the bytes are right there
+ * in the data URI the caller sent (`data:application/pdf;base64,...`), and the
+ * Python SDK keeps them, so this complement reads them back off the request and
+ * repairs the part.
  *
  * Wraps `startSpan({ type, params })`, which is where the instrumentor builds
  * `gen_ai.input.messages`, so the attribute is already on the span when this
@@ -24,16 +25,16 @@ function asObject(value) {
         ? value
         : null;
 }
-/** The mime type of the data URI a request content block carries, if any. */
-function getBlockMimeType(block) {
+/** The blob part holding the data URI a request content block carries, if any. */
+function getBlockBlobPart(block) {
     const fileBlock = asObject(asObject(block)?.file);
     if (fileBlock === null)
         return null;
-    return (0, get_data_uri_mime_type_1.getDataUriMimeType)(String(fileBlock.file_data ?? ''));
+    return (0, get_data_uri_mime_type_1.getDataUriBlobPart)(String(fileBlock.file_data ?? ''));
 }
 /**
  * `gen_ai.input.messages` with every blob part whose request block carried a
- * data URI given that URI's mime type, or null when there was nothing to
+ * data URI given that URI's mime type and bytes, or null when there was nothing to
  * repair (so the instrumentor's own JSON is left untouched).
  */
 function repairFileMimeTypes(inputMessagesJson, messages) {
@@ -55,11 +56,14 @@ function repairFileMimeTypes(inputMessagesJson, messages) {
         if (!Array.isArray(content) || !Array.isArray(parts))
             return;
         content.forEach((block, blockIndex) => {
-            const mimeType = getBlockMimeType(block);
+            const blobPart = getBlockBlobPart(block);
             const part = asObject(parts[blockIndex]);
-            if (mimeType === null || part?.type !== 'blob' || part.mime_type === mimeType)
+            if (blobPart === null || part?.type !== 'blob')
                 return;
-            part.mime_type = mimeType;
+            if (part.mime_type === blobPart.mime_type && part.content === blobPart.content)
+                return;
+            part.mime_type = blobPart.mime_type;
+            part.content = blobPart.content;
             repaired = true;
         });
     });

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

@@ -0,0 +1,16 @@
+/**
+ * Reasoning effort capture for the OpenAI chat endpoint.
+ *
+ * A chat request asks a model to think with `reasoning_effort` ("low",
+ * "medium", ...). OpenLLMetry's Python instrumentor stamps it as
+ * `gen_ai.request.reasoning_effort`; `@traceloop/instrumentation-openai` (Node)
+ * records nothing, so the stored call would not say how hard the model was
+ * asked to think. This stamps the same attribute when the span opens, in the
+ * `startSpan({ params })` hook the structured-output complement uses. The
+ * Responses endpoint's `reasoning.effort` is stamped by `get_responses_telemetry.ts`.
+ */
+export declare class OpenAIReasoningEffortInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Reasoning effort capture for the OpenAI chat endpoint.
+ *
+ * A chat request asks a model to think with `reasoning_effort` ("low",
+ * "medium", ...). OpenLLMetry's Python instrumentor stamps it as
+ * `gen_ai.request.reasoning_effort`; `@traceloop/instrumentation-openai` (Node)
+ * records nothing, so the stored call would not say how hard the model was
+ * asked to think. This stamps the same attribute when the span opens, in the
+ * `startSpan({ params })` hook the structured-output complement uses. The
+ * Responses endpoint's `reasoning.effort` is stamped by `get_responses_telemetry.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIReasoningEffortInstrumentor = void 0;
+const REASONING_EFFORT_ATTR = 'gen_ai.request.reasoning_effort';
+class OpenAIReasoningEffortInstrumentor {
+    // [owner, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals have changed shape:
+    // the worst case is a missing reasoning effort, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const startSpanOriginal = instrumentation.startSpan;
+        if (typeof startSpanOriginal !== 'function')
+            return;
+        instrumentation.startSpan = function startSpanWithReasoningEffort(request) {
+            const span = startSpanOriginal.call(this, request);
+            try {
+                const reasoningEffort = request?.params?.reasoning_effort;
+                if (typeof reasoningEffort === 'string' && reasoningEffort && span?.isRecording?.()) {
+                    span.setAttribute(REASONING_EFFORT_ATTR, reasoningEffort);
+                }
+            }
+            catch {
+                // Telemetry must never break the app's LLM call.
+            }
+            return span;
+        };
+        this._patched.push([instrumentation, 'startSpan', startSpanOriginal]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.OpenAIReasoningEffortInstrumentor = OpenAIReasoningEffortInstrumentor;

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

@@ -9,8 +9,8 @@
  *   1. Input messages. Upstream stringifies the whole `input` into a single
  *      `{role: "user", parts: [{type: "text", content: "<JSON>"}]}` part. That
  *      loses every role and part type, and it buries an inline image or
- *      document's base64 inside a text string, where `strip-media-payloads`
- *      cannot see it and the payload would reach the queue. This rebuilds the
+ *      document's base64 inside a text string, where the ingestion API
+ *      cannot find it. This rebuilds the
  *      per-role, per-part shape the Python instrumentor emits.
  *   2. Response side. Upstream records only the output text, so a tool call or
  *      a reasoning summary is lost, the finish reason is never `tool_call`, and
@@ -34,12 +34,12 @@
  * (`weflayr.document_search.requests`).
  *
  * Inline media is the one deliberate divergence from the Python instrumentor's
- * shape: an `input_file` carrying `file_data` becomes the byte-less
- * `{type: "blob", mime_type}` stub rather than upstream's
- * `{type: "file", file_id, filename}`, so an inline PDF pins the same stub here
+ * shape: an `input_file` carrying `file_data` becomes the
+ * `{type: "blob", mime_type, content}` part rather than upstream's
+ * `{type: "file", file_id, filename}`, so an inline PDF pins the same part here
  * as it does on the chat endpoint. The Python complement makes the same repair.
- * An `input_image` keeps its `data:` URI in a `uri` part, which the shared
- * `strip-media-payloads` step already rewrites to that stub.
+ * An `input_image` keeps its `data:` URI in a `uri` part, which the ingestion
+ * API moves to S3 like any other inline media.
  */
 import { type Span } from '@opentelemetry/api';
 type JsonObject = Record<string, any>;

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

@@ -10,8 +10,8 @@
  *   1. Input messages. Upstream stringifies the whole `input` into a single
  *      `{role: "user", parts: [{type: "text", content: "<JSON>"}]}` part. That
  *      loses every role and part type, and it buries an inline image or
- *      document's base64 inside a text string, where `strip-media-payloads`
- *      cannot see it and the payload would reach the queue. This rebuilds the
+ *      document's base64 inside a text string, where the ingestion API
+ *      cannot find it. This rebuilds the
  *      per-role, per-part shape the Python instrumentor emits.
  *   2. Response side. Upstream records only the output text, so a tool call or
  *      a reasoning summary is lost, the finish reason is never `tool_call`, and
@@ -35,12 +35,12 @@
  * (`weflayr.document_search.requests`).
  *
  * Inline media is the one deliberate divergence from the Python instrumentor's
- * shape: an `input_file` carrying `file_data` becomes the byte-less
- * `{type: "blob", mime_type}` stub rather than upstream's
- * `{type: "file", file_id, filename}`, so an inline PDF pins the same stub here
+ * shape: an `input_file` carrying `file_data` becomes the
+ * `{type: "blob", mime_type, content}` part rather than upstream's
+ * `{type: "file", file_id, filename}`, so an inline PDF pins the same part here
  * as it does on the chat endpoint. The Python complement makes the same repair.
- * An `input_image` keeps its `data:` URI in a `uri` part, which the shared
- * `strip-media-payloads` step already rewrites to that stub.
+ * An `input_image` keeps its `data:` URI in a `uri` part, which the ingestion
+ * API moves to S3 like any other inline media.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIResponsesInstrumentor = void 0;
@@ -106,7 +106,7 @@ function parseArguments(rawArguments) {
  *
  * Example: `{type: "input_text", text: "hi"}` -> `{type: "text", content: "hi"}`;
  * `{type: "input_file", filename: "a.pdf", file_data: "data:application/pdf;base64,..."}`
- * -> `{type: "blob", mime_type: "application/pdf"}`.
+ * -> `{type: "blob", mime_type: "application/pdf", content: "..."}`.
  */
 function buildInputPart(block) {
     if (!isJsonObject(block)) {
@@ -123,9 +123,9 @@ function buildInputPart(block) {
         return { type: 'file', modality: 'image', file_id: block.file_id ?? null };
     }
     if (blockType === 'file' || blockType === 'input_file' || blockType === 'output_file') {
-        const mimeType = (0, get_data_uri_mime_type_1.getDataUriMimeType)(String(block.file_data ?? ''));
-        if (mimeType !== null) {
-            return { type: 'blob', mime_type: mimeType };
+        const blobPart = (0, get_data_uri_mime_type_1.getDataUriBlobPart)(String(block.file_data ?? ''));
+        if (blobPart !== null) {
+            return blobPart;
         }
         return {
             type: 'file',

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/instrumentation/openai/set_telemetry_attributes.d.ts

@@ -19,7 +19,8 @@
  *     OpenAI-compatible API (Alibaba Model Studio, xAI), and
  *   - the billing of the calls to Vertex AI's OpenAI-compatible endpoint, and
  *   - a `reasoning_content` output part for any provider that returns one, and
- *   - the service tier the call was served in (flex, priority, ...).
+ *   - the service tier the call was served in (flex, priority, ...), and
+ *   - the reasoning effort a chat request asks for.
  */
 export declare class OpenAITelemetryInstrumentor {
     private _subInstrumentors;

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

@@ -20,7 +20,8 @@
  *     OpenAI-compatible API (Alibaba Model Studio, xAI), and
  *   - the billing of the calls to Vertex AI's OpenAI-compatible endpoint, and
  *   - a `reasoning_content` output part for any provider that returns one, and
- *   - the service tier the call was served in (flex, priority, ...).
+ *   - the service tier the call was served in (flex, priority, ...), and
+ *   - the reasoning effort a chat request asks for.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAITelemetryInstrumentor = void 0;
@@ -33,6 +34,7 @@ const get_openai_compatible_provider_telemetry_1 = require("./get_openai_compati
 const get_responses_telemetry_1 = require("./get_responses_telemetry");
 const get_embeddings_telemetry_1 = require("./get_embeddings_telemetry");
 const get_reasoning_content_telemetry_1 = require("./get_reasoning_content_telemetry");
+const get_reasoning_effort_telemetry_1 = require("./get_reasoning_effort_telemetry");
 const get_service_tier_telemetry_1 = require("./get_service_tier_telemetry");
 const get_streaming_usage_1 = require("./get_streaming_usage");
 const get_cache_and_reasoning_telemetry_1 = require("./get_cache_and_reasoning_telemetry");
@@ -57,6 +59,7 @@ class OpenAITelemetryInstrumentor {
             new get_vertex_openai_compatible_telemetry_1.VertexOpenAICompatibleInstrumentor(),
             new get_reasoning_content_telemetry_1.OpenAIReasoningContentInstrumentor(),
             new get_service_tier_telemetry_1.OpenAIServiceTierInstrumentor(),
+            new get_reasoning_effort_telemetry_1.OpenAIReasoningEffortInstrumentor(),
             new get_structured_output_schema_telemetry_1.TraceloopStructuredOutputSchemaInstrumentor(get_structured_output_schema_telemetry_2.readStructuredOutputSchema),
         ];
     }

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,10 +17,9 @@
 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 strip_media_payloads_1 = require("./strip-media-payloads");
 const logger_1 = require("../logger");
 // setup({captureMessageContent: ...}) records the choice in this env var (the
 // official OTel GenAI one). Instrumentors gate content on their own knobs
@@ -74,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;
@@ -115,9 +114,6 @@ class WeflayrSpanProcessor {
                     delete span.attributes[key];
             }
         }
-        else {
-            (0, strip_media_payloads_1.stripMediaPayloads)(span.attributes);
-        }
         if (this._mask) {
             try {
                 const masked = this._mask(span.attributes);

package/dist/src/propagate-metadata-to-gateway.js

@@ -2,10 +2,15 @@
 /**
  * Send the metadata of a call to the Weflayr AI gateway in a request header.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._state = exports.PUBLIC_GATEWAY_HOST = exports.WEFLAYR_METADATA_HEADER = void 0;
 exports.buildMetadataHeaderValue = buildMetadataHeaderValue;
 exports.enablePropagateMetadataToGateway = enablePropagateMetadataToGateway;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const api_1 = require("@opentelemetry/api");
 const logger_1 = require("./logger");
 const propagation_1 = require("./otel/propagation");
@@ -155,6 +160,30 @@ function addMetadataHeader(client, options) {
         (0, logger_1.debug)('enablePropagateMetadataToGateway: could not add the metadata header');
     }
 }
+// The ES module build sits next to the CommonJS one (`index.mjs` next to
+// `index.js`), as openai's package exports name it.
+function requireEsmOpenAI() {
+    const esmEntryPath = node_path_1.default.join(node_path_1.default.dirname(require.resolve('openai')), 'index.mjs');
+    // An openai version with no ES module build has only its CommonJS class.
+    if (!node_fs_1.default.existsSync(esmEntryPath)) {
+        return undefined;
+    }
+    return require(esmEntryPath).OpenAI;
+}
+function patchPrepareOptions(OpenAI) {
+    // `prepareOptions` is the openai client's documented hook for mutating a
+    // request's options, and it runs for every endpoint, streaming or not.
+    const originalPrepareOptions = OpenAI.prototype.prepareOptions;
+    if (typeof originalPrepareOptions !== 'function') {
+        throw new Error('weflayr.enablePropagateMetadataToGateway: the openai client has no ' +
+            'prepareOptions hook, so the installed openai version cannot send the ' +
+            'metadata header.');
+    }
+    OpenAI.prototype.prepareOptions = async function prepareOptions(options) {
+        await originalPrepareOptions.call(this, options);
+        addMetadataHeader(this, options);
+    };
+}
 /**
  * Send `propagateMetadata` and `setCallName` values to the Weflayr AI gateway.
  *
@@ -196,18 +225,16 @@ function enablePropagateMetadataToGateway(gatewayBaseUrl) {
             'call the Weflayr AI gateway. Install it with: npm install openai\n' +
             `Underlying error: ${err.message}`);
     }
-    // `prepareOptions` is the openai client's documented hook for mutating a
-    // request's options, and it runs for every endpoint, streaming or not.
-    const originalPrepareOptions = OpenAI.prototype.prepareOptions;
-    if (typeof originalPrepareOptions !== 'function') {
-        throw new Error('weflayr.enablePropagateMetadataToGateway: the openai client has no ' +
-            'prepareOptions hook, so the installed openai version cannot send the ' +
-            'metadata header.');
+    // openai ships a CommonJS and an ES module build, each with its own client
+    // class: an app writing `import OpenAI from 'openai'` gets the ES module one,
+    // which `require` never returns. Node loads that build with `require` too.
+    // It is loaded before any class is patched, so a build failing to load
+    // leaves both unpatched and a later call patches each once.
+    const esmOpenAI = requireEsmOpenAI();
+    patchPrepareOptions(OpenAI);
+    if (esmOpenAI !== undefined && esmOpenAI !== OpenAI) {
+        patchPrepareOptions(esmOpenAI);
     }
-    OpenAI.prototype.prepareOptions = async function prepareOptions(options) {
-        await originalPrepareOptions.call(this, options);
-        addMetadataHeader(this, options);
-    };
     exports._state.openaiClientsPatched = true;
     (0, logger_1.debug)('enablePropagateMetadataToGateway: patched the openai client gatewayHostAndPort=%s', exports._state.gatewayHostAndPort ?? exports.PUBLIC_GATEWAY_HOST);
 }

package/dist/src/setup.js

@@ -4,7 +4,9 @@ exports._state = void 0;
 exports.setup = setup;
 exports.flush = flush;
 const api_1 = require("@opentelemetry/api");
-const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const context_async_hooks_1 = require("@opentelemetry/context-async-hooks");
+const core_1 = require("@opentelemetry/core");
+const sdk_trace_1 = require("@opentelemetry/sdk-trace");
 const resources_1 = require("@opentelemetry/resources");
 const exporter_1 = require("./otel/exporter");
 const span_processor_1 = require("./otel/span-processor");
@@ -18,7 +20,7 @@ exports._state = {
     beforeExitListener: null,
 };
 // `trace.getTracerProvider()` returns a ProxyTracerProvider that forwards to
-// whoever called `.register()` last. Unwrap it to reach the real provider.
+// whoever called `trace.setGlobalTracerProvider()` first. Unwrap it to reach the real provider.
 // The delegate/registration internals aren't part of the public TracerProvider
 // type, so this reaches into them dynamically.
 function _unwrapTracerProvider(p) {
@@ -28,7 +30,7 @@ function _unwrapTracerProvider(p) {
     }
     return p;
 }
-// `NodeTracerProvider` 2.x dropped the public `addSpanProcessor` API —
+// The SDK `TracerProvider` has no public `addSpanProcessor` API —
 // processors are construction-time only. To attach to a provider somebody
 // else owns, we splice into the internal MultiSpanProcessor. This matches
 // the actual public OTel JS guidance for composing post-construction.
@@ -47,6 +49,16 @@ function _attachProcessorToExistingProvider(provider, processor) {
     }
     return false;
 }
+// Registers the provider, an AsyncLocalStorage context manager (which
+// `propagateMetadata` relies on) and the W3C trace context + baggage
+// propagators. Each global is kept if something else already set it.
+function _registerGlobally(tracerProvider) {
+    api_1.trace.setGlobalTracerProvider(tracerProvider);
+    api_1.context.setGlobalContextManager(new context_async_hooks_1.AsyncLocalStorageContextManager().enable());
+    api_1.propagation.setGlobalPropagator(new core_1.CompositePropagator({
+        propagators: [new core_1.W3CTraceContextPropagator(), new core_1.W3CBaggagePropagator()],
+    }));
+}
 /**
  * Configure the Weflayr SDK.
  *
@@ -88,7 +100,7 @@ function setup(options) {
     });
     // Adopt an existing TracerProvider when there is one — e.g. the user already
     // configured Datadog/Honeycomb/OTel, or called weflayr.setup() before.
-    // provider.register() silently refuses to override the proxy if another
+    // trace.setGlobalTracerProvider() silently refuses to override the proxy if another
     // provider is already wired in, so naively creating a new provider would
     // leave our processor attached to a dead one and we'd drop every LLM span.
     const currentTracerProvider = _unwrapTracerProvider(api_1.trace.getTracerProvider());
@@ -97,15 +109,15 @@ function setup(options) {
         tracerProvider = currentTracerProvider;
     }
     else {
-        const nodeTracerProvider = new sdk_trace_node_1.NodeTracerProvider({
+        const sdkTracerProvider = new sdk_trace_1.TracerProvider({
             resource: (0, resources_1.resourceFromAttributes)({
                 sdk_version: package_json_1.version,
                 sdk_language: SDK_LANGUAGE,
             }),
             spanProcessors: [processor],
         });
-        nodeTracerProvider.register();
-        tracerProvider = nodeTracerProvider;
+        _registerGlobally(sdkTracerProvider);
+        tracerProvider = sdkTracerProvider;
     }
     // beforeExit fires when the event loop empties on a clean exit, giving us a
     // last async tick to drain buffered spans. It does NOT fire on process.exit()