weflayr 0.29.0 → 0.29.1

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "weflayr",
-    "version": "0.29.0",
+    "version": "0.29.1",
     "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/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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weflayr",
-  "version": "0.29.0",
+  "version": "0.29.1",
   "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",