weflayr 0.28.0 → 0.29.1

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "weflayr",
-    "version": "0.28.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,15 +31,15 @@
     },
     "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",
         "async-retry": "^1.3.3"
     },
     "overrides": {
-        "js-yaml": "^4.3.1"
+        "js-yaml": "^4.3.2"
     },
     "devDependencies": {
         "@hey-api/openapi-ts": "^0.99.0",

package/dist/src/auto-instrument.js

@@ -14,7 +14,7 @@ exports.AiSdk = Object.freeze({
     ELEVENLABS: 'elevenlabs',
     MISTRAL: 'mistral',
 });
-// Allowed values for `propagateMetadata({ providerNameOverride })`: the actual AI
+// Allowed values for `propagateMetadata({ providerNameOverrideIfTelemetryInstrumentation })`: the actual AI
 // providers a call can be attributed to. Unlike AiSdk this names providers,
 // not SDKs — google-genai is an SDK whose calls are labeled google or vertex,
 // and mistral can also be reached through the OpenAI SDK (OpenAI-compatible

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/dist/src/otel/propagation.d.ts

@@ -10,14 +10,14 @@ declare const EXTRA_TAG_PREFIX = "weflayr.tag.";
 export interface PropagateMetadataOptions {
     /** Product-side feature triggering the LLM call (e.g. `"onboarding-summary"`). */
     featureName: string;
-    /** Name of the end-user / tenant customer the call is made for. */
-    customerName: string;
     /**
-     * Override for the provider seen on the wire. Set this only if it differs
-     * from the SDK auto-detected by OpenTelemetry, e.g. Mistral calls made
-     * through the OpenAI SDK, which should be reported as `mistral`.
+     * Name of the end-user / tenant customer the call is made for. When
+     * omitted, the calls are recorded with no customer. A call sent through the
+     * Weflayr AI gateway can name its customer in the request body instead,
+     * e.g. `{ ..., weflayr: { customer_name: 'Acme' } }`, which suits a
+     * customer known only where the call is made.
      */
-    providerNameOverride?: AIProviderName;
+    customerName?: string;
     /**
      * Arbitrary scalar key/value pairs to attach. Values must be `string`,
      * `number`, or `boolean` so they survive the ClickHouse `Map(String,
@@ -32,6 +32,15 @@ export interface PropagateMetadataOptions {
      * hexadecimal characters. When omitted, each invocation creates its own.
      */
     featureRunUuid?: string;
+    /**
+     * Override for the provider seen on the wire, for a call the SDK's telemetry
+     * instrumentation records. Set this only if it differs from the SDK
+     * auto-detected by OpenTelemetry, e.g. Mistral calls made through the OpenAI
+     * SDK, which should be reported as `mistral`. Ignored, with a warning, for a
+     * call sent through the Weflayr AI gateway, which reports the provider it
+     * called itself.
+     */
+    providerNameOverrideIfTelemetryInstrumentation?: AIProviderName;
 }
 export declare function getMergedMetadataFromContext(parentContext?: Context): Record<string, unknown>;
 /**

package/dist/src/otel/propagation.js

@@ -7,7 +7,8 @@
 // This file has been modified from its original form:
 //   - Translated from TypeScript to JavaScript
 //   - Replaced Langfuse's fixed schema with Weflayr's structured metadata
-//     (featureName, customerName, providerNameOverride, extraTags) plus an
+//     (featureName, customerName, extraTags,
+//     providerNameOverrideIfTelemetryInstrumentation) plus an
 //     auto-generated per-call uuid
 //   - Added `setCallName`, a nested scope naming one LLM call
 //   - Removed asBaggage cross-process propagation (not needed yet)
@@ -45,17 +46,20 @@ function getMergedMetadataFromContext(parentContext) {
     const existing = ctx.getValue(WEFLAYR_METADATA_CONTEXT_KEY);
     return existing && typeof existing === 'object' ? { ...existing } : {};
 }
-function _buildAttributes({ featureName, customerName, providerNameOverride, extraTags, spanUuid, }) {
+function _buildAttributes({ featureName, customerName, extraTags, spanUuid, providerNameOverrideIfTelemetryInstrumentation, }) {
     const attributes = {
         [FEATURE_NAME_ATTR]: featureName,
-        [CUSTOMER_NAME_ATTR]: customerName,
         [UUID_ATTR]: spanUuid,
     };
     for (const [key, value] of Object.entries(extraTags)) {
         attributes[`${EXTRA_TAG_PREFIX}${key}`] = value;
     }
-    if (providerNameOverride !== undefined && providerNameOverride !== null) {
-        attributes[BILLING_PROVIDER_ATTR] = providerNameOverride;
+    if (customerName !== undefined && customerName !== null) {
+        attributes[CUSTOMER_NAME_ATTR] = customerName;
+    }
+    if (providerNameOverrideIfTelemetryInstrumentation !== undefined &&
+        providerNameOverrideIfTelemetryInstrumentation !== null) {
+        attributes[BILLING_PROVIDER_ATTR] = providerNameOverrideIfTelemetryInstrumentation;
     }
     return attributes;
 }
@@ -74,9 +78,8 @@ function createFeatureRunUuid() {
     return (0, node_crypto_1.randomUUID)().replace(/-/g, '');
 }
 function propagateMetadata(options, fn) {
-    const { featureName, customerName } = options ?? {};
-    if (featureName == null || customerName == null) {
-        throw new Error('propagateMetadata: `featureName` and `customerName` are required');
+    if (options?.featureName == null) {
+        throw new Error('propagateMetadata: `featureName` is required');
     }
     if (options.featureRunUuid !== undefined &&
         !FEATURE_RUN_UUID_PATTERN.test(options.featureRunUuid)) {
@@ -103,13 +106,13 @@ function propagateMetadata(options, fn) {
     };
 }
 function _runWithMetadata(options, fn) {
-    const { featureName, customerName, providerNameOverride, extraTags, featureRunUuid } = options;
+    const { featureName, customerName, extraTags, featureRunUuid, providerNameOverrideIfTelemetryInstrumentation, } = options;
     return _runWithAttributes(_buildAttributes({
         featureName,
         customerName,
-        providerNameOverride,
         extraTags: extraTags ?? {},
         spanUuid: featureRunUuid ?? createFeatureRunUuid(),
+        providerNameOverrideIfTelemetryInstrumentation,
     }), fn);
 }
 function _runWithAttributes(attributes, fn) {

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

@@ -63,7 +63,7 @@ function escapeNonAscii(json) {
 function buildMetadataHeaderValue() {
     const metadata = (0, propagation_1.getMergedMetadataFromContext)();
     if (propagation_1.BILLING_PROVIDER_ATTR in metadata) {
-        process.emitWarning('propagateMetadata: `providerNameOverride` is ignored for a call sent to the ' +
+        process.emitWarning('propagateMetadata: `providerNameOverrideIfTelemetryInstrumentation` is ignored for a call sent to the ' +
             'Weflayr AI gateway, which reports the provider it called itself');
     }
     const payload = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weflayr",
-  "version": "0.28.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,15 +31,15 @@
   },
   "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",
     "async-retry": "^1.3.3"
   },
   "overrides": {
-    "js-yaml": "^4.3.1"
+    "js-yaml": "^4.3.2"
   },
   "devDependencies": {
     "@hey-api/openapi-ts": "^0.99.0",