weflayr 0.29.0 → 0.30.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "weflayr",
-    "version": "0.29.0",
+    "version": "0.30.0",
     "description": "Weflayr JS/TS SDK — instrument any LLM client",
     "main": "dist/src/index.js",
     "types": "dist/src/index.d.ts",
@@ -31,8 +31,8 @@
     },
     "dependencies": {
         "@opentelemetry/api": "^1.9.1",
-        "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
-        "@opentelemetry/instrumentation": "^0.222.0",
+        "@opentelemetry/exporter-trace-otlp-http": "^0.223.0",
+        "@opentelemetry/instrumentation": "^0.223.0",
         "@opentelemetry/resources": "^2.8.0",
         "@opentelemetry/sdk-trace-base": "^2.8.0",
         "@opentelemetry/sdk-trace-node": "^2.8.0",

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

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

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

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

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

@@ -13,7 +13,9 @@
  * paths) to stamp every breakpoint found in the request as
  * `weflayr.cache.breakpoints`: a JSON list of `{location, ttl}` where location
  * is `system`, `messages[i]`, `tools[i]` or `auto_last_block` (the top-level
- * parameter) and `ttl` is the raw cache_control string, omitted when the
+ * parameter), followed by `.content[j]` for a breakpoint on a block that is not
+ * the last of its system prompt or message (`formatCacheBreakpointLocation`),
+ * and `ttl` is the raw cache_control string, omitted when the
  * breakpoint sets none; the normalizer owns the TTL vocabulary.
  */
 export interface CacheBreakpoint {

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

@@ -14,12 +14,15 @@
  * paths) to stamp every breakpoint found in the request as
  * `weflayr.cache.breakpoints`: a JSON list of `{location, ttl}` where location
  * is `system`, `messages[i]`, `tools[i]` or `auto_last_block` (the top-level
- * parameter) and `ttl` is the raw cache_control string, omitted when the
+ * parameter), followed by `.content[j]` for a breakpoint on a block that is not
+ * the last of its system prompt or message (`formatCacheBreakpointLocation`),
+ * and `ttl` is the raw cache_control string, omitted when the
  * breakpoint sets none; the normalizer owns the TTL vocabulary.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnthropicCacheConfigInstrumentor = void 0;
 exports.extractCacheBreakpoints = extractCacheBreakpoints;
+const format_cache_breakpoint_location_1 = require("../shared/format_cache_breakpoint_location");
 const BREAKPOINTS_ATTR = 'weflayr.cache.breakpoints';
 // A breakpoint as location + the raw cache_control `ttl` string, omitted when
 // the request sets none.
@@ -27,22 +30,26 @@ function _breakpointEntry(location, cacheControl) {
     const ttl = cacheControl && cacheControl.ttl;
     return ttl ? { location, ttl: String(ttl) } : { location };
 }
-function _cacheControlsInBlocks(blocks) {
+// A breakpoint per block of `blocks` carrying a `cache_control`.
+function _breakpointsInBlocks(blocks, messageLocation) {
     if (!Array.isArray(blocks))
         return [];
-    return blocks.map((block) => block && block.cache_control).filter(Boolean);
+    const breakpoints = [];
+    blocks.forEach((block, blockIndex) => {
+        const cacheControl = block && block.cache_control;
+        if (!cacheControl)
+            return;
+        const location = (0, format_cache_breakpoint_location_1.formatCacheBreakpointLocation)(messageLocation, blockIndex, blocks.length);
+        breakpoints.push(_breakpointEntry(location, cacheControl));
+    });
+    return breakpoints;
 }
 // Every `cache_control` breakpoint in the request, as location + the raw
 // `ttl` string (omitted when the breakpoint sets none).
 function extractCacheBreakpoints(params) {
-    const breakpoints = [];
-    for (const cacheControl of _cacheControlsInBlocks(params.system)) {
-        breakpoints.push(_breakpointEntry('system', cacheControl));
-    }
+    const breakpoints = _breakpointsInBlocks(params.system, 'system');
     (params.messages || []).forEach((message, index) => {
-        for (const cacheControl of _cacheControlsInBlocks(message && message.content)) {
-            breakpoints.push(_breakpointEntry(`messages[${index}]`, cacheControl));
-        }
+        breakpoints.push(..._breakpointsInBlocks(message && message.content, `messages[${index}]`));
     });
     (params.tools || []).forEach((tool, index) => {
         if (tool && tool.cache_control) {

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

@@ -29,6 +29,7 @@ exports.BedrockCacheConfigInstrumentor = void 0;
 exports.recordCommandRegion = recordCommandRegion;
 exports.extractBedrockCacheBreakpoints = extractBedrockCacheBreakpoints;
 const get_cache_config_telemetry_1 = require("../anthropic/get_cache_config_telemetry");
+const format_cache_breakpoint_location_1 = require("../shared/format_cache_breakpoint_location");
 const BREAKPOINTS_ATTR = 'weflayr.cache.breakpoints';
 const PROVIDER_REGION_ATTR = 'weflayr.provider_region';
 // The region of the client each pending command was sent with. Keyed by the
@@ -46,13 +47,46 @@ function _cachePointEntry(location, cachePoint) {
     const ttl = cachePoint && cachePoint.ttl;
     return ttl ? { location, ttl: String(ttl) } : { location };
 }
-// The first `cachePoint` among a list of blocks (attached to a content block,
-// or standing alone as its own block), or undefined.
-function _cachePointOfBlocks(blocks) {
+function _isStandaloneCachePoint(block) {
+    return (block != null &&
+        typeof block === 'object' &&
+        Object.keys(block).length === 1 &&
+        block.cachePoint !== undefined);
+}
+// A breakpoint per `cachePoint` among a list of blocks. One attached to a
+// content block marks that block, and one standing alone as its own block
+// marks the content block before it, the standalone ones being no content
+// block of their own. A standalone one opening the list caches the prompt up
+// to `previousLocation`, the end of what comes before the list, and is left
+// out when nothing does, since it then caches nothing.
+// Example: [text, cachePoint, text] in messages[0] ->
+// [{ location: "messages[0].content[0]" }].
+function _cachePointBreakpoints(blocks, messageLocation, previousLocation) {
     if (!Array.isArray(blocks))
-        return undefined;
-    const block = blocks.find((entry) => entry && entry.cachePoint != null);
-    return block && block.cachePoint;
+        return [];
+    const numContentBlocks = blocks.filter((block) => !_isStandaloneCachePoint(block)).length;
+    const breakpoints = [];
+    let numContentBlocksSoFar = 0;
+    for (const block of blocks) {
+        if (!_isStandaloneCachePoint(block))
+            numContentBlocksSoFar += 1;
+        const cachePoint = block && block.cachePoint;
+        if (cachePoint == null)
+            continue;
+        const markedBlockIndex = numContentBlocksSoFar - 1;
+        let location;
+        if (markedBlockIndex >= 0) {
+            location = (0, format_cache_breakpoint_location_1.formatCacheBreakpointLocation)(messageLocation, markedBlockIndex, numContentBlocks);
+        }
+        else if (previousLocation !== undefined) {
+            location = previousLocation;
+        }
+        else {
+            continue;
+        }
+        breakpoints.push(_cachePointEntry(location, cachePoint));
+    }
+    return breakpoints;
 }
 // Every cache breakpoint in an InvokeModel request body, as location + the
 // raw `ttl` string (omitted when the breakpoint sets none): the
@@ -60,17 +94,15 @@ function _cachePointOfBlocks(blocks) {
 // (which never overlap in one body).
 function extractBedrockCacheBreakpoints(body) {
     const breakpoints = (0, get_cache_config_telemetry_1.extractCacheBreakpoints)(body);
-    const systemCachePoint = _cachePointOfBlocks(body.system);
-    if (systemCachePoint != null) {
-        breakpoints.push(_cachePointEntry('system', systemCachePoint));
-    }
+    const tools = (body.toolConfig && body.toolConfig.tools) || [];
+    // The prompt is cached in the order tools, system, messages.
+    const toolsLocation = tools.length ? `tools[${tools.length - 1}]` : undefined;
+    breakpoints.push(..._cachePointBreakpoints(body.system, 'system', toolsLocation));
+    const locationBeforeMessages = body.system && body.system.length ? 'system' : toolsLocation;
     (body.messages || []).forEach((message, index) => {
-        const cachePoint = _cachePointOfBlocks(message && message.content);
-        if (cachePoint != null) {
-            breakpoints.push(_cachePointEntry(`messages[${index}]`, cachePoint));
-        }
+        const previousLocation = index ? `messages[${index - 1}]` : locationBeforeMessages;
+        breakpoints.push(..._cachePointBreakpoints(message && message.content, `messages[${index}]`, previousLocation));
     });
-    const tools = (body.toolConfig && body.toolConfig.tools) || [];
     tools.forEach((tool, index) => {
         if (tool && tool.cachePoint != null) {
             breakpoints.push(_cachePointEntry(`tools[${index}]`, tool.cachePoint));

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

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

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

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

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

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

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

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

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

@@ -6,7 +6,7 @@
  * `gen_ai.input.messages` as a bare `{"type": "<block type>"}` (the fallback
  * branch of its `formatting.ts`), so a PDF sent as `document_url` is stored
  * under a name with no mime type, where every other provider stores the
- * byte-less `{"type": "blob", "mime_type": "application/pdf"}`.
+ * `{"type": "blob", "mime_type": "application/pdf", "content": <base64>}`.
  *
  * The mime type it lacks is in the request the caller sent: the block's url is
  * a `data:` URI holding the bytes. This complement walks the parts the tracing

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

@@ -7,7 +7,7 @@
  * `gen_ai.input.messages` as a bare `{"type": "<block type>"}` (the fallback
  * branch of its `formatting.ts`), so a PDF sent as `document_url` is stored
  * under a name with no mime type, where every other provider stores the
- * byte-less `{"type": "blob", "mime_type": "application/pdf"}`.
+ * `{"type": "blob", "mime_type": "application/pdf", "content": <base64>}`.
  *
  * The mime type it lacks is in the request the caller sent: the block's url is
  * a `data:` URI holding the bytes. This complement walks the parts the tracing
@@ -38,20 +38,17 @@ function getBlockUrl(block) {
     return String(url ?? '');
 }
 /**
- * The byte-less part for a content block carrying inline bytes, or null for a
- * block that carries none.
+ * The blob part for a content block carrying inline bytes, or null for a block
+ * that carries none.
  *
  * e.g. `{"type": "document_url", "document_url": "data:application/pdf;base64,AAA"}`
- * -> `{"type": "blob", "mime_type": "application/pdf"}`.
+ * -> `{"type": "blob", "mime_type": "application/pdf", "content": "AAA"}`.
  */
 function getMediaStub(rawBlock) {
     const block = asObject(rawBlock);
     if (block === null)
         return null;
-    const mimeType = (0, get_data_uri_mime_type_1.getDataUriMimeType)(getBlockUrl(block));
-    if (mimeType === null)
-        return null;
-    return { type: 'blob', mime_type: mimeType };
+    return (0, get_data_uri_mime_type_1.getDataUriBlobPart)(getBlockUrl(block));
 }
 /** True for the `{"type": "<block type>"}` the tracing falls back to on a
  * block it does not shape: a type and nothing else. */

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

@@ -13,9 +13,11 @@
  *
  * 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.
+ * `input` (Responses), recorded as `messages[i]` / `input[i]`, followed by
+ * `.content[j]` for a marker on a block that is not the last of its message
+ * (`formatCacheBreakpointLocation`). 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`

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

@@ -14,9 +14,11 @@
  *
  * 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.
+ * `input` (Responses), recorded as `messages[i]` / `input[i]`, followed by
+ * `.content[j]` for a marker on a block that is not the last of its message
+ * (`formatCacheBreakpointLocation`). 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`
@@ -41,6 +43,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAICacheConfigInstrumentor = void 0;
+const format_cache_breakpoint_location_1 = require("../shared/format_cache_breakpoint_location");
 const CACHE_KEY_ATTR = 'weflayr.cache.key';
 const CACHE_RETENTION_ATTR = 'weflayr.cache.retention';
 const CACHE_MODE_ATTR = 'weflayr.cache.mode';
@@ -55,20 +58,21 @@ function breakpointsInItems(items, listName, firstIndex) {
         const content = item && item.content;
         if (!Array.isArray(content))
             return;
-        for (const block of content) {
+        content.forEach((block, blockIndex) => {
             if (!block || typeof block !== 'object')
-                continue;
+                return;
+            const location = (0, format_cache_breakpoint_location_1.formatCacheBreakpointLocation)(`${listName}[${index}]`, blockIndex, content.length);
             if ('prompt_cache_breakpoint' in block) {
-                breakpoints.push({ location: `${listName}[${index}]` });
+                breakpoints.push({ location });
             }
             const cacheControl = block.cache_control;
             if (cacheControl && typeof cacheControl === 'object') {
-                const entry = { location: `${listName}[${index}]` };
+                const entry = { location };
                 if (cacheControl.ttl)
                     entry.ttl = String(cacheControl.ttl);
                 breakpoints.push(entry);
             }
-        }
+        });
     });
     return breakpoints;
 }

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/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/instrumentation/shared/format_cache_breakpoint_location.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The location of a cache breakpoint marked on one block of a message, shared
+ * by every provider complement stamping `weflayr.cache.breakpoints`.
+ *
+ * A breakpoint caches the prompt up to the end of the block it marks. On a
+ * message's last block, that is the end of the message, written as the message
+ * alone (`messages[1]`). On an earlier block, the prefix ends inside the
+ * message, so the location also names the block (`messages[1].content[0]`).
+ */
+export declare function formatCacheBreakpointLocation(messageLocation: string, blockIndex: number, numBlocks: number): string;

package/dist/src/instrumentation/shared/format_cache_breakpoint_location.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * The location of a cache breakpoint marked on one block of a message, shared
+ * by every provider complement stamping `weflayr.cache.breakpoints`.
+ *
+ * A breakpoint caches the prompt up to the end of the block it marks. On a
+ * message's last block, that is the end of the message, written as the message
+ * alone (`messages[1]`). On an earlier block, the prefix ends inside the
+ * message, so the location also names the block (`messages[1].content[0]`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCacheBreakpointLocation = formatCacheBreakpointLocation;
+// Where a breakpoint on block `blockIndex` of a message of `numBlocks` blocks
+// ends the cached prefix.
+// Example: ("messages[1]", 0, 2) -> "messages[1].content[0]",
+// ("messages[1]", 1, 2) -> "messages[1]".
+function formatCacheBreakpointLocation(messageLocation, blockIndex, numBlocks) {
+    if (blockIndex === numBlocks - 1)
+        return messageLocation;
+    return `${messageLocation}.content[${blockIndex}]`;
+}

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

@@ -20,7 +20,6 @@ const api_1 = require("@opentelemetry/api");
 const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
 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
@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weflayr",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Weflayr JS/TS SDK — instrument any LLM client",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
-    "@opentelemetry/instrumentation": "^0.222.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.223.0",
+    "@opentelemetry/instrumentation": "^0.223.0",
     "@opentelemetry/resources": "^2.8.0",
     "@opentelemetry/sdk-trace-base": "^2.8.0",
     "@opentelemetry/sdk-trace-node": "^2.8.0",

package/dist/src/otel/strip-media-payloads.d.ts

@@ -1,26 +0,0 @@
-/**
- * Remove media payloads (base64 images, audio, documents) from the message
- * content span attributes, right before export.
- *
- * An inline image, audio clip or document reaches the span in one of five shapes,
- * depending on the instrumentor: a `blob` part carrying the base64 bytes in
- * `content` (OpenAI chat completions, Anthropic), a `uri` part whose uri is a
- * `data:` URI holding the same bytes (OpenAI Responses), Anthropic's own content
- * block with the bytes under `source.data` (Bedrock), an OpenAI `file` block
- * with the bytes under `file.file_data`, an OpenAI Responses `input_audio` block
- * kept whole under `content` with the bytes under `content.input_audio.data`. A single
- * image is hundreds of kilobytes, so keeping it would make every event on the
- * queue that much bigger for nothing: the payload is never read back.
- *
- * Each of those becomes `{"type": "blob", "mime_type": "<mime_type>"}`, the same
- * byte-less stub the google, cohere and bedrock instrumentation complements
- * build themselves: the analyses reading these messages still see that the call
- * carried content the stored text does not. A `uri` part pointing at a hosted
- * image is a reference, not a payload, and is kept as is.
- */
-import type { OtelSpanAttributes } from './span-processor';
-/**
- * Rewrite in place every message content attribute of `attributes` that carries
- * media bytes.
- */
-export declare function stripMediaPayloads(attributes: OtelSpanAttributes): void;

package/dist/src/otel/strip-media-payloads.js

@@ -1,135 +0,0 @@
-"use strict";
-/**
- * Remove media payloads (base64 images, audio, documents) from the message
- * content span attributes, right before export.
- *
- * An inline image, audio clip or document reaches the span in one of five shapes,
- * depending on the instrumentor: a `blob` part carrying the base64 bytes in
- * `content` (OpenAI chat completions, Anthropic), a `uri` part whose uri is a
- * `data:` URI holding the same bytes (OpenAI Responses), Anthropic's own content
- * block with the bytes under `source.data` (Bedrock), an OpenAI `file` block
- * with the bytes under `file.file_data`, an OpenAI Responses `input_audio` block
- * kept whole under `content` with the bytes under `content.input_audio.data`. A single
- * image is hundreds of kilobytes, so keeping it would make every event on the
- * queue that much bigger for nothing: the payload is never read back.
- *
- * Each of those becomes `{"type": "blob", "mime_type": "<mime_type>"}`, the same
- * byte-less stub the google, cohere and bedrock instrumentation complements
- * build themselves: the analyses reading these messages still see that the call
- * carried content the stored text does not. A `uri` part pointing at a hosted
- * image is a reference, not a payload, and is kept as is.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stripMediaPayloads = stripMediaPayloads;
-const get_data_uri_mime_type_1 = require("../get-data-uri-mime-type");
-// The message content attributes whose JSON holds parts: the first two are
-// `[{role, parts}]`, `gen_ai.system_instructions` is a flat parts array.
-const MESSAGE_PARTS_ATTRIBUTES = [
-    'gen_ai.input.messages',
-    'gen_ai.output.messages',
-    'gen_ai.system_instructions',
-];
-function isJsonObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function stripPart(part) {
-    if (!isJsonObject(part))
-        return part;
-    if (part.type === 'blob') {
-        return { type: 'blob', mime_type: String(part.mime_type ?? '') };
-    }
-    if (part.type === 'uri') {
-        const mimeType = (0, get_data_uri_mime_type_1.getDataUriMimeType)(String(part.uri ?? ''));
-        if (mimeType !== null)
-            return { type: 'blob', mime_type: mimeType };
-    }
-    // Anthropic's own content block, which the Bedrock instrumentor copies onto
-    // the span as is: the bytes sit under source.data whatever the block's type
-    // says ("image", "document", "video", "audio").
-    const source = part.source;
-    if (isJsonObject(source) && source.data != null) {
-        return { type: 'blob', mime_type: String(source.media_type ?? '') };
-    }
-    // OpenAI's file block (a PDF sent to chat completions). On Node the
-    // instrumentor already maps it to a blob part (see the openai complement that
-    // repairs its mime type), so this is the guard for the day it stops, and the
-    // mirror of the branch the Python SDK needs.
-    const fileBlock = part.file;
-    if (isJsonObject(fileBlock)) {
-        const mimeType = (0, get_data_uri_mime_type_1.getDataUriMimeType)(String(fileBlock.file_data ?? ''));
-        if (mimeType !== null)
-            return { type: 'blob', mime_type: mimeType };
-    }
-    // An input block the OpenAI Responses instrumentor does not recognize is
-    // recorded as `{"type": "<block type>", "content": <the block itself>}`, so an
-    // `input_audio` block puts its base64 clip under `content.input_audio.data`.
-    const unrecognizedBlock = part.content;
-    const inlineAudio = isJsonObject(unrecognizedBlock) ? unrecognizedBlock.input_audio : null;
-    if (isJsonObject(inlineAudio) && inlineAudio.data != null) {
-        const audioFormat = inlineAudio.format;
-        return {
-            type: 'blob',
-            mime_type: audioFormat ? `audio/${audioFormat}` : 'audio/unknown',
-        };
-    }
-    // Mistral's document block. Its own tracing names the block by its type and
-    // drops the payload, so what arrives is usually `{"type": "document_url"}`
-    // already; this is what keeps the bytes off the queue if it stops dropping
-    // them.
-    const documentMimeType = (0, get_data_uri_mime_type_1.getDataUriMimeType)(String(part.document_url ?? ''));
-    if (documentMimeType !== null)
-        return { type: 'blob', mime_type: documentMimeType };
-    return part;
-}
-/**
- * `items` with `stripItem` applied to each of them, or `items` itself when
- * every item came back unchanged - an attribute carrying no media then keeps
- * the instrumentor's exact JSON string.
- */
-function stripList(items, stripItem) {
-    const stripped = items.map(stripItem);
-    return stripped.every((item, index) => item === items[index]) ? items : stripped;
-}
-/**
- * One entry of a parts attribute: a message whose `parts` are stripped, or a
- * bare part when the attribute is a flat parts array.
- */
-function stripPartsEntry(entry) {
-    if (isJsonObject(entry) && Array.isArray(entry.parts)) {
-        const parts = stripList(entry.parts, stripPart);
-        return parts === entry.parts ? entry : { ...entry, parts };
-    }
-    return stripPart(entry);
-}
-/**
- * The attribute's JSON with the media stripped from each of its entries, or
- * null when there was nothing to strip.
- */
-function getStrippedAttribute(value) {
-    if (typeof value !== 'string')
-        return null;
-    let entries;
-    try {
-        entries = JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
-    if (!Array.isArray(entries))
-        return null;
-    const stripped = stripList(entries, stripPartsEntry);
-    return stripped === entries ? null : JSON.stringify(stripped);
-}
-/**
- * Rewrite in place every message content attribute of `attributes` that carries
- * media bytes.
- */
-function stripMediaPayloads(attributes) {
-    for (const key of MESSAGE_PARTS_ATTRIBUTES) {
-        if (key in attributes) {
-            const stripped = getStrippedAttribute(attributes[key]);
-            if (stripped !== null)
-                attributes[key] = stripped;
-        }
-    }
-}