weflayr 0.27.0 → 0.28.0

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

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Request-side prompt-caching config capture for OpenAI chat spans.
+ * Request-side param capture for OpenAI chat and Responses spans.
  *
  * OpenAI callers influence the (automatic, server-side) prompt cache with
  * request parameters the traceloop instrumentor never records:
@@ -12,15 +12,32 @@
  * message content block (`prompt_cache_options: { mode: "explicit" }`
  * disables the automatic breakpoint, requiring these to cache anything).
  *
+ * It covers the chat and the Responses endpoints alike: both take the same
+ * params, and a marker sits on a content block of either `messages` (chat) or
+ * `input` (Responses), recorded as `messages[i]` / `input[i]`. A Responses
+ * request's `instructions` count as its item 0 when it sends them, as the
+ * worker numbers every provider's system prompt.
+ *
  * Wrap `startSpan({ type, params })` (covering the streamed and non-streamed
  * paths) to stamp the values as `weflayr.cache.key` / `weflayr.cache.retention`
  * (raw retention/ttl string) and, when any content block carries the marker,
- * `weflayr.cache.breakpoints` (a JSON list of `{"location": "messages[i]"}`
- * entries — the marker itself carries no TTL, unlike Anthropic's
- * `cache_control`; the normalizer owns the vocabulary).
+ * `weflayr.cache.breakpoints`: a JSON list of `{"location": "messages[i]"}` /
+ * `{"location": "input[i]"}` entries for OpenAI's own `prompt_cache_breakpoint`
+ * marker (which carries no TTL of its own; the normalizer falls back to the
+ * request-level retention and owns the vocabulary) or, for a content block
+ * carrying Anthropic's `cache_control` convention instead (Alibaba (Qwen) is
+ * reached through this same openai-shape client and opts into its *explicit*
+ * cache this way, unlike real OpenAI), `{"location": ..., "ttl": ...}`, the raw
+ * `ttl` string carried on the marker itself, omitted when it sets none.
  * `prompt_cache_options: { mode: "explicit" }` is stamped as
  * `weflayr.cache.mode` so the normalizer knows not to also synthesize the
  * automatic "auto"-location breakpoint OpenAI does not create in this mode.
+ *
+ * The same wrapper stamps the output-token limit when the caller sent it as
+ * `max_completion_tokens`: the traceloop instrumentor reads only `max_tokens`,
+ * which the reasoning models (o-series, GPT-5 and later) reject, so their calls
+ * would record no limit at all. It lives here because this is the one place the
+ * request's own params are read.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAICacheConfigInstrumentor = void 0;
@@ -28,21 +45,39 @@ const CACHE_KEY_ATTR = 'weflayr.cache.key';
 const CACHE_RETENTION_ATTR = 'weflayr.cache.retention';
 const CACHE_MODE_ATTR = 'weflayr.cache.mode';
 const BREAKPOINTS_ATTR = 'weflayr.cache.breakpoints';
-function explicitBreakpoints(params) {
+const MAX_TOKENS_ATTR = 'gen_ai.request.max_tokens';
+function breakpointsInItems(items, listName, firstIndex) {
     const breakpoints = [];
-    const messages = (params && params.messages) || [];
-    messages.forEach((message, index) => {
-        const content = message && message.content;
+    if (!Array.isArray(items))
+        return breakpoints;
+    items.forEach((item, position) => {
+        const index = firstIndex + position;
+        const content = item && item.content;
         if (!Array.isArray(content))
             return;
         for (const block of content) {
-            if (block && typeof block === 'object' && 'prompt_cache_breakpoint' in block) {
-                breakpoints.push({ location: `messages[${index}]` });
+            if (!block || typeof block !== 'object')
+                continue;
+            if ('prompt_cache_breakpoint' in block) {
+                breakpoints.push({ location: `${listName}[${index}]` });
+            }
+            const cacheControl = block.cache_control;
+            if (cacheControl && typeof cacheControl === 'object') {
+                const entry = { location: `${listName}[${index}]` };
+                if (cacheControl.ttl)
+                    entry.ttl = String(cacheControl.ttl);
+                breakpoints.push(entry);
             }
         }
     });
     return breakpoints;
 }
+function explicitBreakpoints(params) {
+    return [
+        ...breakpointsInItems(params && params.messages, 'messages', 0),
+        ...breakpointsInItems(params && params.input, 'input', params && params.instructions ? 1 : 0),
+    ];
+}
 class OpenAICacheConfigInstrumentor {
     // [instrumentation, methodName, originalFunction] for uninstrument().
     _patched = [];
@@ -54,7 +89,7 @@ class OpenAICacheConfigInstrumentor {
         const startSpanOriginal = instrumentation.startSpan;
         if (typeof startSpanOriginal !== 'function')
             return;
-        instrumentation.startSpan = function startSpanWithCacheConfig(request) {
+        instrumentation.startSpan = function startSpanWithRequestParams(request) {
             const span = startSpanOriginal.call(this, request);
             try {
                 const params = (request && request.params) || {};
@@ -73,6 +108,10 @@ class OpenAICacheConfigInstrumentor {
                 if (breakpoints.length) {
                     span.setAttribute(BREAKPOINTS_ATTR, JSON.stringify(breakpoints));
                 }
+                // `max_tokens` is already stamped by traceloop, and no model takes both.
+                if (params.max_completion_tokens !== undefined && params.max_completion_tokens !== null) {
+                    span.setAttribute(MAX_TOKENS_ATTR, params.max_completion_tokens);
+                }
             }
             catch {
                 // Never break span creation over an enrichment failure.

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

@@ -15,14 +15,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIEmbeddingsInstrumentor = void 0;
 const api_1 = require("@opentelemetry/api");
+const get_openai_compatible_provider_telemetry_1 = require("./get_openai_compatible_provider_telemetry");
 const TRACER_NAME = 'weflayr.instrumentation.openai_embeddings';
 const EMBEDDINGS_OPERATION = 'embeddings';
+const EMBEDDINGS_INPUT_ATTR = 'weflayr.embeddings.input';
 // Return the gen_ai.system for this call, matching how the OpenAI chat
 // instrumentor attributes the vendor: Azure clients (reached via the same openai
-// SDK) report `azure.ai.openai`, everything else `openai`.
+// SDK) report `azure.ai.openai`, Alibaba Model Studio clients report `alibaba`
+// (see get_openai_compatible_provider_telemetry.ts for the exact hosts
+// recognized), everything else `openai`. The other vendor that file knows, xAI,
+// is not checked here: xAI serves no embedding model.
 function _detectSystem(instance) {
     const baseURL = (instance && instance._client && instance._client.baseURL) || '';
-    return baseURL.toLowerCase().includes('openai.azure.com') ? 'azure.ai.openai' : 'openai';
+    if (baseURL.toLowerCase().includes('openai.azure.com'))
+        return 'azure.ai.openai';
+    if ((0, get_openai_compatible_provider_telemetry_1.isProviderBaseURL)(get_openai_compatible_provider_telemetry_1.ALIBABA_PROVIDER, baseURL))
+        return get_openai_compatible_provider_telemetry_1.ALIBABA_PROVIDER.providerName;
+    return 'openai';
 }
 function _recordError(span, error) {
     span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error?.message ?? String(error) });
@@ -50,12 +59,11 @@ class OpenAIEmbeddingsInstrumentor {
             if (body && body.model) {
                 span.setAttribute('gen_ai.request.model', body.model);
             }
-            // One user message per input element, matching the shape the chat
-            // instrumentors emit. The span processor strips it when message-content
-            // capture is disabled.
+            // The embedded inputs, as passed (one or a list); the worker shapes them.
+            // The span processor strips it when message-content capture is disabled.
             if (body && body.input != null) {
                 const inputs = Array.isArray(body.input) ? body.input : [body.input];
-                span.setAttribute('gen_ai.input.messages', JSON.stringify(inputs.map((content) => ({ role: 'user', parts: [{ type: 'text', content }] }))));
+                span.setAttribute(EMBEDDINGS_INPUT_ATTR, JSON.stringify(inputs));
             }
             return Promise.resolve(original.call(this, body, ...rest)).then((response) => {
                 if (response && response.model) {

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

@@ -0,0 +1,26 @@
+/**
+ * Mime type of a file (PDF, ...) sent inline to OpenAI chat completions.
+ *
+ * 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.
+ *
+ * Wraps `startSpan({ type, params })`, which is where the instrumentor builds
+ * `gen_ai.input.messages`, so the attribute is already on the span when this
+ * runs. A message's content blocks map one-to-one onto the leading parts of its
+ * message, which is what lets the repair walk them in step.
+ */
+/**
+ * `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
+ * repair (so the instrumentor's own JSON is left untouched).
+ */
+export declare function repairFileMimeTypes(inputMessagesJson: unknown, messages: unknown): string | null;
+export declare class OpenAIFilePartMimeTypeInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Mime type of a file (PDF, ...) sent inline to OpenAI chat completions.
+ *
+ * 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.
+ *
+ * Wraps `startSpan({ type, params })`, which is where the instrumentor builds
+ * `gen_ai.input.messages`, so the attribute is already on the span when this
+ * runs. A message's content blocks map one-to-one onto the leading parts of its
+ * message, which is what lets the repair walk them in step.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIFilePartMimeTypeInstrumentor = void 0;
+exports.repairFileMimeTypes = repairFileMimeTypes;
+const get_data_uri_mime_type_1 = require("../../get-data-uri-mime-type");
+const INPUT_MESSAGES_ATTR = 'gen_ai.input.messages';
+function asObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+/** The mime type of the data URI a request content block carries, if any. */
+function getBlockMimeType(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 ?? ''));
+}
+/**
+ * `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
+ * repair (so the instrumentor's own JSON is left untouched).
+ */
+function repairFileMimeTypes(inputMessagesJson, messages) {
+    if (typeof inputMessagesJson !== 'string' || !Array.isArray(messages))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(inputMessagesJson);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(parsed))
+        return null;
+    let repaired = false;
+    messages.forEach((message, messageIndex) => {
+        const content = asObject(message)?.content;
+        const parts = asObject(parsed[messageIndex])?.parts;
+        if (!Array.isArray(content) || !Array.isArray(parts))
+            return;
+        content.forEach((block, blockIndex) => {
+            const mimeType = getBlockMimeType(block);
+            const part = asObject(parts[blockIndex]);
+            if (mimeType === null || part?.type !== 'blob' || part.mime_type === mimeType)
+                return;
+            part.mime_type = mimeType;
+            repaired = true;
+        });
+    });
+    return repaired ? JSON.stringify(parsed) : null;
+}
+class OpenAIFilePartMimeTypeInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals have changed shape -
+    // the worst case is a document recorded under a vaguer mime type, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const startSpanOriginal = instrumentation.startSpan;
+        if (typeof startSpanOriginal !== 'function')
+            return;
+        instrumentation.startSpan = function startSpanWithFileMimeTypes(request) {
+            const span = startSpanOriginal.call(this, request);
+            try {
+                const repaired = repairFileMimeTypes(span?.attributes?.[INPUT_MESSAGES_ATTR], request?.params?.messages);
+                if (repaired !== null)
+                    span.setAttribute(INPUT_MESSAGES_ATTR, repaired);
+            }
+            catch {
+                // Never break span creation over an enrichment failure.
+            }
+            return span;
+        };
+        this._patched.push([instrumentation, 'startSpan', startSpanOriginal]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.OpenAIFilePartMimeTypeInstrumentor = OpenAIFilePartMimeTypeInstrumentor;

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

@@ -0,0 +1,48 @@
+/**
+ * Vendor detection for the OpenAI chat path of vendors served over an
+ * OpenAI-compatible API.
+ *
+ * Alibaba Cloud Model Studio (DashScope) serves Qwen and other models, and xAI
+ * serves the Grok models, over an OpenAI-compatible API, so both are reached
+ * with the stock `openai` SDK pointed at the vendor's own base URL. The
+ * traceloop instrumentor's own vendor detection (`_detectVendorFromURL`)
+ * recognizes neither domain and falls back to `openai`, so every such call
+ * would otherwise be billed and grouped as OpenAI. One instrumentor per vendor
+ * re-stamps the detected provider for a client whose base URL matches,
+ * resolving the resource to its underlying client the same way
+ * `OpenAIBedrockMantleInstrumentor` does (`_detectVendorFromURL` is sometimes
+ * called with the resource, e.g. `Chat.Completions`, instead of the client).
+ *
+ * The embeddings endpoint is not covered here: traceloop does not wrap it, so
+ * weflayr's own `get_embeddings_telemetry.ts` detects the vendor itself,
+ * through `isProviderBaseURL` below.
+ *
+ * A `/v1/responses` call is attributed differently: its span keeps
+ * `gen_ai.provider.name` as "openai" and gets `weflayr.billing_provider` set to
+ * the vendor's name instead. The worker parses a span by its
+ * `gen_ai.provider.name` and prices it by its billing provider, and a vendor's
+ * Responses API counts its usage as OpenAI's does (xAI's counts the reasoning
+ * tokens inside the output tokens, unlike its Chat Completions API), so the
+ * payload is parsed as OpenAI's and the call priced as the vendor's.
+ */
+export interface OpenAICompatibleProvider {
+    providerName: string;
+    hostnames: Set<string>;
+    hostnameSuffix: string;
+}
+export declare const ALIBABA_PROVIDER: OpenAICompatibleProvider;
+export declare const SPACEXAI_PROVIDER: OpenAICompatibleProvider;
+/** The openai client a traceloop call was made through: the client itself, or
+ * the resource (e.g. `Chat.Completions`) whose `_client` it is. */
+export declare function resolveClient(client: any): any;
+/** Whether a client base URL points at this vendor, e.g.
+ * (SPACEXAI_PROVIDER, 'https://api.x.ai/v1') -> true. */
+export declare function isProviderBaseURL(provider: OpenAICompatibleProvider, baseURL: unknown): boolean;
+export declare class OpenAICompatibleProviderInstrumentor {
+    readonly provider: OpenAICompatibleProvider;
+    private _patched;
+    constructor(provider: OpenAICompatibleProvider);
+    instrument(instrumentation: any): void;
+    private _billResponsesCallsToProvider;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Vendor detection for the OpenAI chat path of vendors served over an
+ * OpenAI-compatible API.
+ *
+ * Alibaba Cloud Model Studio (DashScope) serves Qwen and other models, and xAI
+ * serves the Grok models, over an OpenAI-compatible API, so both are reached
+ * with the stock `openai` SDK pointed at the vendor's own base URL. The
+ * traceloop instrumentor's own vendor detection (`_detectVendorFromURL`)
+ * recognizes neither domain and falls back to `openai`, so every such call
+ * would otherwise be billed and grouped as OpenAI. One instrumentor per vendor
+ * re-stamps the detected provider for a client whose base URL matches,
+ * resolving the resource to its underlying client the same way
+ * `OpenAIBedrockMantleInstrumentor` does (`_detectVendorFromURL` is sometimes
+ * called with the resource, e.g. `Chat.Completions`, instead of the client).
+ *
+ * The embeddings endpoint is not covered here: traceloop does not wrap it, so
+ * weflayr's own `get_embeddings_telemetry.ts` detects the vendor itself,
+ * through `isProviderBaseURL` below.
+ *
+ * A `/v1/responses` call is attributed differently: its span keeps
+ * `gen_ai.provider.name` as "openai" and gets `weflayr.billing_provider` set to
+ * the vendor's name instead. The worker parses a span by its
+ * `gen_ai.provider.name` and prices it by its billing provider, and a vendor's
+ * Responses API counts its usage as OpenAI's does (xAI's counts the reasoning
+ * tokens inside the output tokens, unlike its Chat Completions API), so the
+ * payload is parsed as OpenAI's and the call priced as the vendor's.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleProviderInstrumentor = exports.SPACEXAI_PROVIDER = exports.ALIBABA_PROVIDER = void 0;
+exports.resolveClient = resolveClient;
+exports.isProviderBaseURL = isProviderBaseURL;
+// traceloop's internal tag for the Responses request/response shape, the value
+// it passes to `startSpan`.
+const RESPONSES_TYPE = 'responses';
+const PROVIDER_ATTR = 'gen_ai.provider.name';
+const BILLING_PROVIDER_ATTR = 'weflayr.billing_provider';
+const OPENAI_PROVIDER_NAME = 'openai';
+exports.ALIBABA_PROVIDER = {
+    providerName: 'alibaba',
+    hostnames: new Set(['dashscope.aliyuncs.com', 'dashscope-intl.aliyuncs.com']),
+    hostnameSuffix: '.maas.aliyuncs.com',
+};
+exports.SPACEXAI_PROVIDER = {
+    providerName: 'spacexai',
+    hostnames: new Set(['api.x.ai']),
+    hostnameSuffix: '.api.x.ai',
+};
+/** The openai client a traceloop call was made through: the client itself, or
+ * the resource (e.g. `Chat.Completions`) whose `_client` it is. */
+function resolveClient(client) {
+    return client && !client.baseURL && client._client ? client._client : client;
+}
+/** Whether a client base URL points at this vendor, e.g.
+ * (SPACEXAI_PROVIDER, 'https://api.x.ai/v1') -> true. */
+function isProviderBaseURL(provider, baseURL) {
+    if (typeof baseURL !== 'string' || !baseURL)
+        return false;
+    let hostname;
+    try {
+        hostname = new URL(baseURL).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return provider.hostnames.has(hostname) || hostname.endsWith(provider.hostnameSuffix);
+}
+class OpenAICompatibleProviderInstrumentor {
+    provider;
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    constructor(provider) {
+        this.provider = provider;
+    }
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const original = instrumentation._detectVendorFromURL;
+        if (typeof original !== 'function')
+            return;
+        const provider = this.provider;
+        instrumentation._detectVendorFromURL = function detectVendorWithProvider(client) {
+            const resolved = resolveClient(client);
+            if (isProviderBaseURL(provider, resolved?.baseURL)) {
+                return { provider: provider.providerName };
+            }
+            return original.call(this, resolved);
+        };
+        this._patched.push([instrumentation, '_detectVendorFromURL', original]);
+        this._billResponsesCallsToProvider(instrumentation);
+    }
+    // A Responses span of this vendor is parsed as OpenAI's and billed to the
+    // vendor (see the module comment).
+    _billResponsesCallsToProvider(instrumentation) {
+        const original = instrumentation.startSpan;
+        if (typeof original !== 'function')
+            return;
+        const provider = this.provider;
+        instrumentation.startSpan = function startSpanBilledToProvider(args) {
+            const span = original.call(this, args);
+            try {
+                if (args?.type === RESPONSES_TYPE &&
+                    span?.isRecording?.() &&
+                    isProviderBaseURL(provider, resolveClient(args.client)?.baseURL)) {
+                    span.setAttribute(PROVIDER_ATTR, OPENAI_PROVIDER_NAME);
+                    span.setAttribute(BILLING_PROVIDER_ATTR, provider.providerName);
+                }
+            }
+            catch {
+                // Never break span creation over an enrichment failure.
+            }
+            return span;
+        };
+        this._patched.push([instrumentation, 'startSpan', original]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.OpenAICompatibleProviderInstrumentor = OpenAICompatibleProviderInstrumentor;

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

@@ -0,0 +1,28 @@
+/**
+ * `reasoning_content` output-part capture for the OpenAI chat path.
+ *
+ * OpenLLMetry's Python instrumentor already renders a message's
+ * `reasoning_content` field as a `{type: "reasoning"}` output part natively (see
+ * `get_bedrock_mantle_telemetry.py`'s docstring), so any OpenAI-compatible
+ * provider returning that field just works there. `@traceloop/instrumentation-openai`
+ * (Node) has no equivalent at all - reasoning models routed through it (Alibaba's
+ * explicit `enable_thinking`, confirmed 2026-09-21; DeepSeek and others use the
+ * same convention) would otherwise record an output message missing their whole
+ * chain of thought. This brings Node to parity, independently of
+ * `OpenAIBedrockMantleInstrumentor`'s `reasoning` (no `_content` suffix) handling
+ * for Mantle's own open-weight models - a response carries one spelling or the
+ * other, never both, so the two complements never collide.
+ *
+ * Mirrors `OpenAIBedrockMantleInstrumentor`'s reasoning mechanics exactly (same
+ * `_endSpan` / `_streamingWrapPromise` hooks, same "insert ahead of the first
+ * non-text part" ordering), reading `reasoning_content` instead of `reasoning`.
+ */
+export declare class OpenAIReasoningContentInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    /** Accumulate `delta.reasoning_content` across the streamed chunks. */
+    private _patchStreamedReasoning;
+    /** Add the reasoning part as the output message is written. */
+    private _patchOutputMessages;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * `reasoning_content` output-part capture for the OpenAI chat path.
+ *
+ * OpenLLMetry's Python instrumentor already renders a message's
+ * `reasoning_content` field as a `{type: "reasoning"}` output part natively (see
+ * `get_bedrock_mantle_telemetry.py`'s docstring), so any OpenAI-compatible
+ * provider returning that field just works there. `@traceloop/instrumentation-openai`
+ * (Node) has no equivalent at all - reasoning models routed through it (Alibaba's
+ * explicit `enable_thinking`, confirmed 2026-09-21; DeepSeek and others use the
+ * same convention) would otherwise record an output message missing their whole
+ * chain of thought. This brings Node to parity, independently of
+ * `OpenAIBedrockMantleInstrumentor`'s `reasoning` (no `_content` suffix) handling
+ * for Mantle's own open-weight models - a response carries one spelling or the
+ * other, never both, so the two complements never collide.
+ *
+ * Mirrors `OpenAIBedrockMantleInstrumentor`'s reasoning mechanics exactly (same
+ * `_endSpan` / `_streamingWrapPromise` hooks, same "insert ahead of the first
+ * non-text part" ordering), reading `reasoning_content` instead of `reasoning`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIReasoningContentInstrumentor = void 0;
+const OUTPUT_MESSAGES_ATTR = 'gen_ai.output.messages';
+// Reasoning streamed so far, per open span. Streamed deltas arrive while the
+// stream is consumed, but the output message is only built when the span ends,
+// so the two hooks below meet here.
+const _streamedReasoningBySpan = new WeakMap();
+function _completeResponseReasoning(result) {
+    const reasoning = result?.choices?.[0]?.message?.reasoning_content;
+    return typeof reasoning === 'string' && reasoning ? reasoning : undefined;
+}
+/** The parts array with the reasoning inserted ahead of the first non-text part
+ * (tool calls, audio, ...), so text and refusal keep leading it. */
+function _withReasoningPart(parts, reasoning) {
+    const reasoningPart = { type: 'reasoning', content: reasoning };
+    const firstNonTextIndex = parts.findIndex((part) => part?.type !== 'text' && part?.type !== 'refusal');
+    if (firstNonTextIndex === -1)
+        return [...parts, reasoningPart];
+    return [...parts.slice(0, firstNonTextIndex), reasoningPart, ...parts.slice(firstNonTextIndex)];
+}
+/** The serialized output messages with the reasoning part added, or null when the
+ * value isn't the expected JSON array of messages. */
+function _addReasoningToOutputMessages(rawOutputMessages, reasoning) {
+    if (typeof rawOutputMessages !== 'string')
+        return null;
+    let messages;
+    try {
+        messages = JSON.parse(rawOutputMessages);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(messages) || messages.length === 0)
+        return null;
+    const [first, ...rest] = messages;
+    if (!first || !Array.isArray(first.parts))
+        return null;
+    return JSON.stringify([{ ...first, parts: _withReasoningPart(first.parts, reasoning) }, ...rest]);
+}
+class OpenAIReasoningContentInstrumentor {
+    // [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 chain of thought, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        this._patchStreamedReasoning(instrumentation);
+        this._patchOutputMessages(instrumentation);
+    }
+    /** Accumulate `delta.reasoning_content` across the streamed chunks. */
+    _patchStreamedReasoning(instrumentation) {
+        const original = instrumentation._streamingWrapPromise;
+        if (typeof original !== 'function')
+            return;
+        instrumentation._streamingWrapPromise = function streamingWrapWithReasoningContent(streamArgs) {
+            const span = streamArgs && streamArgs.span;
+            const wrappedStream = original.call(this, streamArgs);
+            if (!span)
+                return wrappedStream;
+            return (async function* accumulateReasoningContent() {
+                for await (const chunk of wrappedStream) {
+                    const reasoning = chunk?.choices?.[0]?.delta?.reasoning_content;
+                    if (typeof reasoning === 'string' && reasoning) {
+                        _streamedReasoningBySpan.set(span, (_streamedReasoningBySpan.get(span) ?? '') + reasoning);
+                    }
+                    yield chunk;
+                }
+            })();
+        };
+        this._patched.push([instrumentation, '_streamingWrapPromise', original]);
+    }
+    /** Add the reasoning part as the output message is written. */
+    _patchOutputMessages(instrumentation) {
+        const original = instrumentation._endSpan;
+        if (typeof original !== 'function')
+            return;
+        instrumentation._endSpan = function endSpanWithReasoningContent(args) {
+            const span = args && args.span;
+            const reasoning = _completeResponseReasoning(args && args.result) ??
+                (span ? _streamedReasoningBySpan.get(span) : undefined);
+            if (!span || !reasoning)
+                return original.call(this, args);
+            // The original builds the output messages and then ends the span, so the
+            // part is grafted on as the attribute is written rather than afterwards.
+            const previousSetAttribute = span.setAttribute;
+            span.setAttribute = function setAttributeWithReasoningContent(key, value) {
+                if (key === OUTPUT_MESSAGES_ATTR) {
+                    value = _addReasoningToOutputMessages(value, reasoning) ?? value;
+                }
+                return previousSetAttribute.call(this, key, value);
+            };
+            try {
+                return original.call(this, args);
+            }
+            finally {
+                span.setAttribute = previousSetAttribute;
+                _streamedReasoningBySpan.delete(span);
+            }
+        };
+        this._patched.push([instrumentation, '_endSpan', original]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.OpenAIReasoningContentInstrumentor = OpenAIReasoningContentInstrumentor;