weflayr 0.26.1 → 0.28.0

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

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

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

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Media parts of the input messages on Mistral chat spans.
+ *
+ * The SDK's built-in tracing shapes exactly two kinds of content block: text,
+ * and `image_url`, which it records as a `uri` part. Every other block reaches
+ * `gen_ai.input.messages` as a bare `{"type": "<block type>"}` (the fallback
+ * branch of its `formatting.ts`), so a PDF sent as `document_url` is stored
+ * under a name with no mime type, where every other provider stores the
+ * byte-less `{"type": "blob", "mime_type": "application/pdf"}`.
+ *
+ * The mime type it lacks is in the request the caller sent: the block's url is
+ * a `data:` URI holding the bytes. This complement walks the parts the tracing
+ * just stamped alongside the request's blocks and replaces those nameless parts
+ * with the same stub the other providers produce. Blocks the tracing did shape,
+ * and blocks whose url points at a hosted file rather than at inline bytes, are
+ * left alone.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INPUT_MESSAGES_ATTRIBUTE = void 0;
+exports.repairMediaInputParts = repairMediaInputParts;
+exports.setInputMessageContentTelemetry = setInputMessageContentTelemetry;
+const get_data_uri_mime_type_1 = require("../../get-data-uri-mime-type");
+exports.INPUT_MESSAGES_ATTRIBUTE = 'gen_ai.input.messages';
+function asObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+/** The url of a content block, which Mistral names after the block's type:
+ * `{"type": "document_url", "document_url": "data:..."}`. Some blocks wrap it
+ * in a `{"url": ...}` object, as `image_url` does. */
+function getBlockUrl(block) {
+    let url = block[String(block.type ?? '')];
+    const wrappedUrl = asObject(url);
+    if (wrappedUrl)
+        url = wrappedUrl.url;
+    return String(url ?? '');
+}
+/**
+ * The byte-less part for a content block carrying inline bytes, or null for a
+ * block that carries none.
+ *
+ * e.g. `{"type": "document_url", "document_url": "data:application/pdf;base64,AAA"}`
+ * -> `{"type": "blob", "mime_type": "application/pdf"}`.
+ */
+function getMediaStub(rawBlock) {
+    const block = asObject(rawBlock);
+    if (block === null)
+        return null;
+    const mimeType = (0, get_data_uri_mime_type_1.getDataUriMimeType)(getBlockUrl(block));
+    if (mimeType === null)
+        return null;
+    return { type: 'blob', mime_type: mimeType };
+}
+/** True for the `{"type": "<block type>"}` the tracing falls back to on a
+ * block it does not shape: a type and nothing else. */
+function isNamelessMediaPart(part) {
+    const object = asObject(part);
+    return object !== null && Object.keys(object).length === 1 && 'type' in object;
+}
+/**
+ * `gen_ai.input.messages` with every nameless media part replaced by its blob
+ * stub, or null when there was nothing to repair (the tracing's own JSON is
+ * then left untouched).
+ *
+ * A message's content blocks map one-to-one onto its parts, in order, which is
+ * what lets the repair walk them in step.
+ */
+function repairMediaInputParts(inputMessagesJson, requestMessages) {
+    if (typeof inputMessagesJson !== 'string' || !Array.isArray(requestMessages))
+        return null;
+    let messages;
+    try {
+        messages = JSON.parse(inputMessagesJson);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(messages))
+        return null;
+    let repaired = false;
+    const messageCount = Math.min(messages.length, requestMessages.length);
+    for (let messageIndex = 0; messageIndex < messageCount; messageIndex++) {
+        const parts = asObject(messages[messageIndex])?.parts;
+        const content = asObject(requestMessages[messageIndex])?.content;
+        if (!Array.isArray(parts) || !Array.isArray(content))
+            continue;
+        content.forEach((block, index) => {
+            if (index >= parts.length || !isNamelessMediaPart(parts[index]))
+                return;
+            const mediaStub = getMediaStub(block);
+            if (mediaStub !== null) {
+                parts[index] = mediaStub;
+                repaired = true;
+            }
+        });
+    }
+    return repaired ? JSON.stringify(messages) : null;
+}
+/**
+ * Re-stamp `gen_ai.input.messages` when the request carries inline media.
+ *
+ * Only ever rewrites an attribute the tracing already set, so it never adds
+ * message content the tracing did not record.
+ */
+function setInputMessageContentTelemetry(span, requestBody) {
+    const attributes = span.attributes ?? {};
+    const repairedMessages = repairMediaInputParts(attributes[exports.INPUT_MESSAGES_ATTRIBUTE], requestBody.messages);
+    if (repairedMessages !== null) {
+        span.setAttribute(exports.INPUT_MESSAGES_ATTRIBUTE, repairedMessages);
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Structured-output schema capture for Mistral spans.
+ *
+ * Mistral pins an answer to a JSON schema with
+ * `response_format: { type: 'json_schema', json_schema: { schema: {...} } }`.
+ * The SDK's built-in tracing enriches the span with the request's sampling
+ * params, messages and tool definitions, but never the schema. The request
+ * body read here is the one sent on the wire, so its keys are snake_case
+ * whatever the caller wrote.
+ */
+/** The schema under `response_format.json_schema.schema`, or undefined when
+ * the request asked for no structured output. */
+export declare function extractStructuredOutputSchema(requestBody: Record<string, unknown>): unknown;

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

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Structured-output schema capture for Mistral spans.
+ *
+ * Mistral pins an answer to a JSON schema with
+ * `response_format: { type: 'json_schema', json_schema: { schema: {...} } }`.
+ * The SDK's built-in tracing enriches the span with the request's sampling
+ * params, messages and tool definitions, but never the schema. The request
+ * body read here is the one sent on the wire, so its keys are snake_case
+ * whatever the caller wrote.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractStructuredOutputSchema = extractStructuredOutputSchema;
+/** The schema under `response_format.json_schema.schema`, or undefined when
+ * the request asked for no structured output. */
+function extractStructuredOutputSchema(requestBody) {
+    const responseFormat = requestBody.response_format;
+    if (typeof responseFormat !== 'object' || responseFormat === null)
+        return undefined;
+    const jsonSchema = responseFormat.json_schema;
+    if (typeof jsonSchema !== 'object' || jsonSchema === null)
+        return undefined;
+    return jsonSchema.schema;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Tracing for Mistral's models called on Vertex AI through `MistralGCP`.
+ *
+ * `@mistralai/mistralai-gcp` is Mistral's client for its models on Vertex AI
+ * (`rawPredict` / `streamRawPredict`). Unlike `@mistralai/mistralai`, it
+ * registers no `TracingHook`, so the SDK's built-in tracing that
+ * `MistralInstrumentor` opts into never sees its calls. This registers that
+ * same hook, from `@mistralai/mistralai`, on every `MistralGCP` client: its
+ * `SDKHooks` runs `sdkInit` from the client's constructor, where the hook is
+ * registered before the original runs, so the tracing hook's own `sdkInit`
+ * wraps the client's HTTP client too. The client's sub-clients (`chat`, `fim`)
+ * run `sdkInit` again on the same `SDKHooks`, which then registers nothing.
+ *
+ * Next to it, a hook of its own stamps two things the tracing hook cannot know:
+ * - `weflayr.billing_provider` set to `vertex`, which the worker prices by
+ *   (Google bills these calls at Vertex's prices), while `gen_ai.provider.name`,
+ *   which it parses by, stays Mistral's;
+ * - the failure of a call Vertex refuses: its error body is Google's
+ *   (`{"error": {"code": 404, "message": ..., "status": "NOT_FOUND"}}`), not the
+ *   `{"object": "error"}` one the tracing hook recognizes, so it would otherwise
+ *   end the span as a success.
+ */
+export declare const MISTRAL_GCP_HOOKS_MODULE = "@mistralai/mistralai-gcp/hooks/hooks.js";
+export type LoadModule = (specifier: string) => Promise<any>;
+/** Stamps the billing provider when the request is sent, and the failure when
+ * Vertex refuses it, on the span the tracing hook keeps on the hook context. */
+export declare class VertexHook {
+    private readonly tracingSpanKey;
+    constructor(tracingSpanKey: string);
+    beforeRequest(hookContext: any, request: Request): Request;
+    afterError(hookContext: any, response: Response | null, error: unknown): Promise<{
+        response: Response | null;
+        error: unknown;
+    }>;
+}
+/**
+ * The message and the type of the error Vertex answered with. Its body is
+ * Google's error object, alone or in a one-item list, or plain text.
+ *
+ * Example: a 404 whose body is `{"error": {"code": 404, "message": "Not
+ * found.", "status": "NOT_FOUND"}}` gives `["Not found.", "NOT_FOUND"]`, a 400
+ * whose body is `reasoning_effort is not supported` gives
+ * `["reasoning_effort is not supported", null]`.
+ */
+export declare function readVertexError(response: Response): Promise<[string, string | null]>;
+/** Register the tracing hook, and the Vertex one, on every `MistralGCP`. */
+export declare class MistralVertexInstrumentor {
+    private readonly loadModule;
+    private _sdkHooksClass;
+    private _originalSdkInit;
+    constructor(loadModule: LoadModule);
+    instrument(tracingModule: any): Promise<void>;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Tracing for Mistral's models called on Vertex AI through `MistralGCP`.
+ *
+ * `@mistralai/mistralai-gcp` is Mistral's client for its models on Vertex AI
+ * (`rawPredict` / `streamRawPredict`). Unlike `@mistralai/mistralai`, it
+ * registers no `TracingHook`, so the SDK's built-in tracing that
+ * `MistralInstrumentor` opts into never sees its calls. This registers that
+ * same hook, from `@mistralai/mistralai`, on every `MistralGCP` client: its
+ * `SDKHooks` runs `sdkInit` from the client's constructor, where the hook is
+ * registered before the original runs, so the tracing hook's own `sdkInit`
+ * wraps the client's HTTP client too. The client's sub-clients (`chat`, `fim`)
+ * run `sdkInit` again on the same `SDKHooks`, which then registers nothing.
+ *
+ * Next to it, a hook of its own stamps two things the tracing hook cannot know:
+ * - `weflayr.billing_provider` set to `vertex`, which the worker prices by
+ *   (Google bills these calls at Vertex's prices), while `gen_ai.provider.name`,
+ *   which it parses by, stays Mistral's;
+ * - the failure of a call Vertex refuses: its error body is Google's
+ *   (`{"error": {"code": 404, "message": ..., "status": "NOT_FOUND"}}`), not the
+ *   `{"object": "error"}` one the tracing hook recognizes, so it would otherwise
+ *   end the span as a success.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MistralVertexInstrumentor = exports.VertexHook = exports.MISTRAL_GCP_HOOKS_MODULE = void 0;
+exports.readVertexError = readVertexError;
+const api_1 = require("@opentelemetry/api");
+const logger_1 = require("../../logger");
+const is_vertex_base_url_1 = require("../shared/is_vertex_base_url");
+exports.MISTRAL_GCP_HOOKS_MODULE = '@mistralai/mistralai-gcp/hooks/hooks.js';
+const ERROR_TYPE_ATTR = 'error.type';
+const FIRST_ERROR_STATUS_CODE = 400;
+// The codes Node throws for a package that is not installed, from require and
+// from import.
+const MODULE_NOT_FOUND_CODES = new Set(['MODULE_NOT_FOUND', 'ERR_MODULE_NOT_FOUND']);
+/** Stamps the billing provider when the request is sent, and the failure when
+ * Vertex refuses it, on the span the tracing hook keeps on the hook context. */
+class VertexHook {
+    tracingSpanKey;
+    constructor(tracingSpanKey) {
+        this.tracingSpanKey = tracingSpanKey;
+    }
+    beforeRequest(hookContext, request) {
+        // Never break the user's Mistral call over an enrichment failure.
+        try {
+            const span = hookContext?.[this.tracingSpanKey];
+            if (span?.isRecording() && (0, is_vertex_base_url_1.isVertexBaseURL)(request.url)) {
+                span.setAttribute(is_vertex_base_url_1.BILLING_PROVIDER_ATTR, is_vertex_base_url_1.VERTEX_BILLING_PROVIDER);
+            }
+        }
+        catch (err) {
+            (0, logger_1.debug)('mistral vertex: billing provider not stamped: %s', err?.message || err);
+        }
+        return request;
+    }
+    async afterError(hookContext, response, error) {
+        try {
+            await recordVertexError(hookContext?.[this.tracingSpanKey], response);
+        }
+        catch (err) {
+            (0, logger_1.debug)('mistral vertex: error not recorded: %s', err?.message || err);
+        }
+        return { response, error };
+    }
+}
+exports.VertexHook = VertexHook;
+async function recordVertexError(span, response) {
+    if (!span?.isRecording() || !response || response.status < FIRST_ERROR_STATUS_CODE)
+        return;
+    const [errorMessage, errorType] = await readVertexError(response);
+    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: errorMessage });
+    if (errorType)
+        span.setAttribute(ERROR_TYPE_ATTR, errorType);
+}
+/**
+ * The message and the type of the error Vertex answered with. Its body is
+ * Google's error object, alone or in a one-item list, or plain text.
+ *
+ * Example: a 404 whose body is `{"error": {"code": 404, "message": "Not
+ * found.", "status": "NOT_FOUND"}}` gives `["Not found.", "NOT_FOUND"]`, a 400
+ * whose body is `reasoning_effort is not supported` gives
+ * `["reasoning_effort is not supported", null]`.
+ */
+async function readVertexError(response) {
+    const text = await response.clone().text();
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        body = undefined;
+    }
+    if (Array.isArray(body) && body.length > 0)
+        body = body[0];
+    const googleError = typeof body === 'object' && body !== null ? body.error : undefined;
+    if (typeof googleError !== 'object' || googleError === null) {
+        return [text || `HTTP ${response.status}`, null];
+    }
+    const { message, status } = googleError;
+    return [String(message || `HTTP ${response.status}`), status ? String(status) : null];
+}
+/** Register the tracing hook, and the Vertex one, on every `MistralGCP`. */
+class MistralVertexInstrumentor {
+    loadModule;
+    _sdkHooksClass;
+    _originalSdkInit;
+    constructor(loadModule) {
+        this.loadModule = loadModule;
+    }
+    async instrument(tracingModule) {
+        let hooksModule;
+        try {
+            hooksModule = await this.loadModule(exports.MISTRAL_GCP_HOOKS_MODULE);
+        }
+        catch (err) {
+            // Calls to Vertex need @mistralai/mistralai-gcp, a package of its own.
+            if (MODULE_NOT_FOUND_CODES.has(err?.code ?? ''))
+                return;
+            throw err;
+        }
+        if (this._originalSdkInit)
+            return;
+        const { TracingHook, TRACING_SPAN_KEY } = tracingModule;
+        const sdkHooksClass = hooksModule.SDKHooks;
+        const originalSdkInit = sdkHooksClass.prototype.sdkInit;
+        const instrumentedHooks = new WeakSet();
+        sdkHooksClass.prototype.sdkInit = function sdkInitWithTracing(...args) {
+            if (!instrumentedHooks.has(this)) {
+                instrumentedHooks.add(this);
+                const tracingHook = new TracingHook();
+                const vertexHook = new VertexHook(TRACING_SPAN_KEY);
+                this.registerSDKInitHook(tracingHook);
+                this.registerBeforeRequestHook(tracingHook);
+                this.registerBeforeRequestHook(vertexHook);
+                this.registerAfterSuccessHook(tracingHook);
+                // Ahead of the tracing hook, which ends the span.
+                this.registerAfterErrorHook(vertexHook);
+                this.registerAfterErrorHook(tracingHook);
+            }
+            return originalSdkInit.apply(this, args);
+        };
+        this._sdkHooksClass = sdkHooksClass;
+        this._originalSdkInit = originalSdkInit;
+    }
+    uninstrument() {
+        if (!this._originalSdkInit)
+            return;
+        this._sdkHooksClass.prototype.sdkInit = this._originalSdkInit;
+        this._sdkHooksClass = undefined;
+        this._originalSdkInit = undefined;
+    }
+}
+exports.MistralVertexInstrumentor = MistralVertexInstrumentor;

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

@@ -15,6 +15,11 @@
  *     OpenLLMetry instrumentor passes the client correctly, so this gap is
  *     Node-only.
  *
+ *   - **The region is missing.** AWS bills a Bedrock call at the price of the
+ *     region it is sent to, and on Mantle the host names it, so it is read off
+ *     the client's base URL. A call carrying no region is priced by no row at
+ *     all.
+ *
  *   - **The chain of thought is dropped.** Mantle's open-weight models (gpt-oss,
  *     qwen, ...) return their reasoning under `reasoning`, which neither the
  *     output-message builder nor the stream accumulator knows about. Without it a
@@ -25,6 +30,11 @@
 export declare class OpenAIBedrockMantleInstrumentor {
     private _patched;
     instrument(instrumentation: any): void;
+    /**
+     * Stamp the AWS region Mantle's host names, the region AWS bills the call at.
+     * A client reached at another host names no region.
+     */
+    private _patchProviderRegion;
     /** Hand the vendor detection the real client, not the resource it is called with. */
     private _patchVendorDetection;
     /** Accumulate `delta.reasoning` across the streamed chunks. */

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

@@ -16,6 +16,11 @@
  *     OpenLLMetry instrumentor passes the client correctly, so this gap is
  *     Node-only.
  *
+ *   - **The region is missing.** AWS bills a Bedrock call at the price of the
+ *     region it is sent to, and on Mantle the host names it, so it is read off
+ *     the client's base URL. A call carrying no region is priced by no row at
+ *     all.
+ *
  *   - **The chain of thought is dropped.** Mantle's open-weight models (gpt-oss,
  *     qwen, ...) return their reasoning under `reasoning`, which neither the
  *     output-message builder nor the stream accumulator knows about. Without it a
@@ -26,6 +31,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIBedrockMantleInstrumentor = void 0;
 const OUTPUT_MESSAGES_ATTR = 'gen_ai.output.messages';
+const PROVIDER_REGION_ATTR = 'weflayr.provider_region';
+// Mantle's host names the AWS region it serves from.
+const MANTLE_HOST_RE = /bedrock-mantle\.([a-z0-9-]+)\.api\.aws/i;
 // 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.
@@ -72,9 +80,34 @@ class OpenAIBedrockMantleInstrumentor {
         if (!instrumentation)
             return;
         this._patchVendorDetection(instrumentation);
+        this._patchProviderRegion(instrumentation);
         this._patchStreamedReasoning(instrumentation);
         this._patchOutputMessages(instrumentation);
     }
+    /**
+     * Stamp the AWS region Mantle's host names, the region AWS bills the call at.
+     * A client reached at another host names no region.
+     */
+    _patchProviderRegion(instrumentation) {
+        const original = instrumentation.startSpan;
+        if (typeof original !== 'function')
+            return;
+        instrumentation.startSpan = function startSpanWithProviderRegion(request) {
+            const span = original.call(this, request);
+            try {
+                const client = request && request.client;
+                const resolved = client && !client.baseURL && client._client ? client._client : client;
+                const hostMatch = MANTLE_HOST_RE.exec(String((resolved && resolved.baseURL) || ''));
+                if (hostMatch)
+                    span.setAttribute(PROVIDER_REGION_ATTR, hostMatch[1]);
+            }
+            catch {
+                // Never break span creation over an enrichment failure.
+            }
+            return span;
+        };
+        this._patched.push([instrumentation, 'startSpan', original]);
+    }
     /** Hand the vendor detection the real client, not the resource it is called with. */
     _patchVendorDetection(instrumentation) {
         const original = instrumentation._detectVendorFromURL;

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

@@ -7,18 +7,25 @@
  * cached-token count. The Python OpenLLMetry instrumentor sets
  * `gen_ai.usage.cache_read_input_tokens` from the former, so this brings the Node
  * SDK to parity; the latter (GPT-5.6+'s cache-write count) has no OpenLLMetry
- * equivalent on either side, so this is its only source.
+ * equivalent on either side, so this is its only source. Alibaba's explicit
+ * context cache (a `cache_control: {type: "ephemeral"}` marker on a message
+ * content block, confirmed against a real workspace on 2026-09-21) reports the
+ * same fact under the Anthropic-shaped `.cache_creation_input_tokens` key
+ * instead, read here too.
  *
  * It wraps the instrumentor instance's `_endSpan({ span, type, result })`, which
  * finalizes the span after the response resolves, letting us stamp the
  * cached-token counts off `result.usage` while the span is still open.
- * `cache_write_tokens` is stamped as `gen_ai.usage.cache_creation_input_tokens`,
- * the attribute name the normalizer already reads for Anthropic/Bedrock/Vercel.
+ * Either cache-write key is stamped as `gen_ai.usage.cache_creation_input_tokens`,
+ * the attribute name the normalizer already reads for Anthropic/Bedrock.
  *
  * The same hook surfaces the reasoning-token count: reasoning models report it as
- * `usage.completion_tokens_details.reasoning_tokens` (a subset of output_tokens)
- * which the Node instrumentor drops, so this stamps the flat `reasoning_tokens`
- * attribute (the form the Python instrumentor emits and the normalizer reads).
+ * `usage.completion_tokens_details.reasoning_tokens`, which the Node instrumentor
+ * drops, so this stamps the flat `reasoning_tokens` attribute (the form the Python
+ * instrumentor emits and the normalizer reads). OpenAI counts those tokens inside
+ * `completion_tokens`, xAI counts them outside it (see the worker's
+ * `normalizers/spacexai.py`); either way what is stamped here is the raw count the
+ * response reported, and the normalizer decides what to add it to.
  */
 export declare class OpenAIPromptCachingInstrumentor {
     private _patched;

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

@@ -8,18 +8,25 @@
  * cached-token count. The Python OpenLLMetry instrumentor sets
  * `gen_ai.usage.cache_read_input_tokens` from the former, so this brings the Node
  * SDK to parity; the latter (GPT-5.6+'s cache-write count) has no OpenLLMetry
- * equivalent on either side, so this is its only source.
+ * equivalent on either side, so this is its only source. Alibaba's explicit
+ * context cache (a `cache_control: {type: "ephemeral"}` marker on a message
+ * content block, confirmed against a real workspace on 2026-09-21) reports the
+ * same fact under the Anthropic-shaped `.cache_creation_input_tokens` key
+ * instead, read here too.
  *
  * It wraps the instrumentor instance's `_endSpan({ span, type, result })`, which
  * finalizes the span after the response resolves, letting us stamp the
  * cached-token counts off `result.usage` while the span is still open.
- * `cache_write_tokens` is stamped as `gen_ai.usage.cache_creation_input_tokens`,
- * the attribute name the normalizer already reads for Anthropic/Bedrock/Vercel.
+ * Either cache-write key is stamped as `gen_ai.usage.cache_creation_input_tokens`,
+ * the attribute name the normalizer already reads for Anthropic/Bedrock.
  *
  * The same hook surfaces the reasoning-token count: reasoning models report it as
- * `usage.completion_tokens_details.reasoning_tokens` (a subset of output_tokens)
- * which the Node instrumentor drops, so this stamps the flat `reasoning_tokens`
- * attribute (the form the Python instrumentor emits and the normalizer reads).
+ * `usage.completion_tokens_details.reasoning_tokens`, which the Node instrumentor
+ * drops, so this stamps the flat `reasoning_tokens` attribute (the form the Python
+ * instrumentor emits and the normalizer reads). OpenAI counts those tokens inside
+ * `completion_tokens`, xAI counts them outside it (see the worker's
+ * `normalizers/spacexai.py`); either way what is stamped here is the raw count the
+ * response reported, and the normalizer decides what to add it to.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIPromptCachingInstrumentor = void 0;
@@ -44,7 +51,10 @@ class OpenAIPromptCachingInstrumentor {
                 if (cachedTokens && recording) {
                     span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, cachedTokens);
                 }
-                const cacheWriteTokens = usage && usage.prompt_tokens_details && usage.prompt_tokens_details.cache_write_tokens;
+                const cacheWriteTokens = usage &&
+                    usage.prompt_tokens_details &&
+                    (usage.prompt_tokens_details.cache_write_tokens ||
+                        usage.prompt_tokens_details.cache_creation_input_tokens);
                 if (cacheWriteTokens && recording) {
                     span.setAttribute(CACHE_CREATION_INPUT_TOKENS_ATTR, cacheWriteTokens);
                 }

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

@@ -1,5 +1,5 @@
 /**
- * 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:
@@ -11,15 +11,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.
  */
 export declare class OpenAICacheConfigInstrumentor {
     private _patched;