weflayr 0.26.1 → 0.28.0

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

@@ -0,0 +1,135 @@
+"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;
+        }
+    }
+}

package/dist/src/propagate-metadata-to-gateway.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Send the metadata of a call to the Weflayr AI gateway in a request header.
+ */
+export declare const WEFLAYR_METADATA_HEADER = "x-weflayr-metadata";
+export declare const PUBLIC_GATEWAY_HOST = "gateway.weflayr.com";
+export declare const _state: {
+    gatewayHostAndPort: string | undefined;
+    openaiClientsPatched: boolean;
+};
+/**
+ * The current scope's metadata as the JSON `WEFLAYR_METADATA_HEADER` holds.
+ *
+ * Returns `undefined` outside any `propagateMetadata` and `setCallName` scope,
+ * where there is nothing to send. Inside
+ * `propagateMetadata({ featureName: 'onboarding', customerName: 'Acme' })`,
+ * returns `'{"feature_name":"onboarding","customer_name":"Acme",
+ * "feature_run_uuid":"e3b0c442..."}'`.
+ */
+export declare function buildMetadataHeaderValue(): string | undefined;
+/**
+ * Send `propagateMetadata` and `setCallName` values to the Weflayr AI gateway.
+ *
+ * Call it once at startup. Every request an `openai` client then sends to the
+ * gateway carries the metadata of the scope it is made in, in the
+ * `x-weflayr-metadata` header. Requests to any other host are left alone, and
+ * clients built before this call are covered too, since the patch is on the
+ * openai client class rather than on an instance.
+ *
+ * No event is exported for a call sent to the gateway: the gateway reports that
+ * call itself, so exporting the SDK's span too would store the call twice.
+ *
+ * @param gatewayBaseUrl The gateway's base URL when it is not the public
+ *   `https://gateway.weflayr.com`, for instance a gateway running locally. Only
+ *   its host and port are compared, and calling this again without it keeps the
+ *   gateway already named.
+ */
+export declare function enablePropagateMetadataToGateway(gatewayBaseUrl?: string): void;

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

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Send the metadata of a call to the Weflayr AI gateway in a request header.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._state = exports.PUBLIC_GATEWAY_HOST = exports.WEFLAYR_METADATA_HEADER = void 0;
+exports.buildMetadataHeaderValue = buildMetadataHeaderValue;
+exports.enablePropagateMetadataToGateway = enablePropagateMetadataToGateway;
+const api_1 = require("@opentelemetry/api");
+const logger_1 = require("./logger");
+const propagation_1 = require("./otel/propagation");
+const span_filter_1 = require("./otel/span-filter");
+// The gateway reads a call's metadata from this header, as a JSON object. A
+// header value has to be ASCII, so a customer name written with an accent
+// travels as JSON's own \uXXXX escape (see escapeNonAscii).
+exports.WEFLAYR_METADATA_HEADER = 'x-weflayr-metadata';
+exports.PUBLIC_GATEWAY_HOST = 'gateway.weflayr.com';
+// The port a base URL points at when it names none, so "https://host/v1" and
+// "https://host:443/v1" are read as the same gateway.
+const DEFAULT_PORT_BY_SCHEME = { 'http:': '80', 'https:': '443' };
+// The instrumentation scopes whose spans cover one openai call: only such a span
+// is the call's own, and only it is stamped as sent to the gateway. Both SDKs'
+// spellings are listed so the two stay identical.
+const OPENAI_INSTRUMENTATION_SCOPES = [
+    'opentelemetry.instrumentation.openai',
+    'opentelemetry.instrumentation.openai_v2',
+    '@traceloop/instrumentation-openai',
+    'weflayr.instrumentation.openai',
+];
+// Span attribute the value is read from -> key the gateway reads it under.
+const HEADER_KEY_BY_SPAN_ATTRIBUTE = {
+    [propagation_1.FEATURE_NAME_ATTR]: 'feature_name',
+    [propagation_1.CUSTOMER_NAME_ATTR]: 'customer_name',
+    [propagation_1.CALL_NAME_ATTR]: 'call_name',
+    [propagation_1.UUID_ATTR]: 'feature_run_uuid',
+};
+exports._state = { gatewayHostAndPort: undefined, openaiClientsPatched: false };
+/**
+ * Rewrite every character above ASCII as JSON's `\uXXXX` escape.
+ *
+ * `JSON.stringify` leaves them as they are, and a header value can only hold
+ * ASCII. Each UTF-16 code unit is escaped on its own, which is what JSON asks
+ * for: an emoji's surrogate pair becomes the two escapes `\ud83d\ude00`.
+ *
+ * Example: `escapeNonAscii('{"customer_name":"Café"}')` returns
+ * `'{"customer_name":"Caf\u00e9"}'`.
+ */
+function escapeNonAscii(json) {
+    return json.replace(/[^\x00-\x7F]/g, (character) => {
+        const codeUnit = character.charCodeAt(0).toString(16).padStart(4, '0');
+        return `\\u${codeUnit}`;
+    });
+}
+/**
+ * The current scope's metadata as the JSON `WEFLAYR_METADATA_HEADER` holds.
+ *
+ * Returns `undefined` outside any `propagateMetadata` and `setCallName` scope,
+ * where there is nothing to send. Inside
+ * `propagateMetadata({ featureName: 'onboarding', customerName: 'Acme' })`,
+ * returns `'{"feature_name":"onboarding","customer_name":"Acme",
+ * "feature_run_uuid":"e3b0c442..."}'`.
+ */
+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 ' +
+            'Weflayr AI gateway, which reports the provider it called itself');
+    }
+    const payload = {};
+    for (const [spanAttribute, key] of Object.entries(HEADER_KEY_BY_SPAN_ATTRIBUTE)) {
+        if (spanAttribute in metadata) {
+            payload[key] = String(metadata[spanAttribute]);
+        }
+    }
+    const tags = {};
+    for (const [spanAttribute, value] of Object.entries(metadata)) {
+        if (spanAttribute.startsWith(propagation_1.EXTRA_TAG_PREFIX)) {
+            tags[spanAttribute.slice(propagation_1.EXTRA_TAG_PREFIX.length)] = String(value);
+        }
+    }
+    if (Object.keys(tags).length > 0) {
+        payload.tags = tags;
+    }
+    if (Object.keys(payload).length === 0) {
+        return undefined;
+    }
+    return escapeNonAscii(JSON.stringify(payload));
+}
+/**
+ * The host and port a base URL points at, the port filled in from the scheme
+ * when the URL names none.
+ *
+ * Example: `readHostAndPort('https://gateway.weflayr.com/v1')` returns
+ * `'gateway.weflayr.com:443'`. Throws on a string that names no host, which
+ * includes `'localhost:8787'`: with no scheme, `URL` reads `localhost:` as the
+ * scheme and leaves the host empty.
+ */
+function readHostAndPort(baseUrl) {
+    const parsed = new URL(baseUrl);
+    if (!parsed.hostname) {
+        throw new Error(`no host in ${baseUrl}`);
+    }
+    const port = parsed.port || DEFAULT_PORT_BY_SCHEME[parsed.protocol] || '';
+    return `${parsed.hostname.toLowerCase()}:${port}`;
+}
+/** Whether a client's base URL is the gateway `enable...` was told about. */
+function isWeflayrGatewayBaseUrl(baseUrl) {
+    const hostAndPort = readHostAndPort(baseUrl);
+    if (exports._state.gatewayHostAndPort !== undefined) {
+        return hostAndPort === exports._state.gatewayHostAndPort;
+    }
+    const hostname = hostAndPort.slice(0, hostAndPort.lastIndexOf(':'));
+    return hostname === exports.PUBLIC_GATEWAY_HOST || hostname.endsWith(`.${exports.PUBLIC_GATEWAY_HOST}`);
+}
+/** Stamp the span of the openai call being sent, when one is being recorded. */
+function markCurrentSpanAsSentToGateway() {
+    const span = api_1.trace.getActiveSpan();
+    if (!span || !span.isRecording()) {
+        return;
+    }
+    const scopeName = span.instrumentationScope?.name ?? '';
+    const isOpenaiCallSpan = OPENAI_INSTRUMENTATION_SCOPES.some((scope) => scopeName === scope || scopeName.startsWith(`${scope}.`));
+    if (isOpenaiCallSpan) {
+        span.setAttribute(span_filter_1.SENT_TO_WEFLAYR_GATEWAY_ATTR, true);
+    }
+}
+/**
+ * Add the metadata header to `options` when the client calls the gateway.
+ *
+ * Swallows its own failures: this runs inside the app's own LLM call, which
+ * telemetry must never break. The caller's own headers are kept whichever shape
+ * they were passed in (a `Headers`, an array of pairs or a plain object), which
+ * is why they go through `Headers` rather than an object spread.
+ *
+ * The span is marked before the header is built, not after: the request is sent
+ * to the gateway either way, so a span left unmarked because building the header
+ * threw would be exported on top of the event the gateway reports, storing one
+ * call twice and doubling its cost. A call whose header never made it is stored
+ * once, with no feature, customer or call name.
+ */
+function addMetadataHeader(client, options) {
+    try {
+        if (!isWeflayrGatewayBaseUrl(String(client?.baseURL ?? ''))) {
+            return;
+        }
+        markCurrentSpanAsSentToGateway();
+        const headerValue = buildMetadataHeaderValue();
+        if (headerValue !== undefined) {
+            const headers = new Headers(options.headers ?? undefined);
+            headers.set(exports.WEFLAYR_METADATA_HEADER, headerValue);
+            options.headers = headers;
+        }
+    }
+    catch {
+        (0, logger_1.debug)('enablePropagateMetadataToGateway: could not add the metadata header');
+    }
+}
+/**
+ * Send `propagateMetadata` and `setCallName` values to the Weflayr AI gateway.
+ *
+ * Call it once at startup. Every request an `openai` client then sends to the
+ * gateway carries the metadata of the scope it is made in, in the
+ * `x-weflayr-metadata` header. Requests to any other host are left alone, and
+ * clients built before this call are covered too, since the patch is on the
+ * openai client class rather than on an instance.
+ *
+ * No event is exported for a call sent to the gateway: the gateway reports that
+ * call itself, so exporting the SDK's span too would store the call twice.
+ *
+ * @param gatewayBaseUrl The gateway's base URL when it is not the public
+ *   `https://gateway.weflayr.com`, for instance a gateway running locally. Only
+ *   its host and port are compared, and calling this again without it keeps the
+ *   gateway already named.
+ */
+function enablePropagateMetadataToGateway(gatewayBaseUrl) {
+    if (gatewayBaseUrl !== undefined) {
+        let hostAndPort;
+        try {
+            hostAndPort = readHostAndPort(gatewayBaseUrl);
+        }
+        catch {
+            throw new Error('weflayr.enablePropagateMetadataToGateway: `gatewayBaseUrl` needs a scheme ' +
+                `and a host, e.g. http://localhost:8787/v1, got: ${gatewayBaseUrl}`);
+        }
+        exports._state.gatewayHostAndPort = hostAndPort;
+    }
+    if (exports._state.openaiClientsPatched) {
+        return;
+    }
+    let OpenAI;
+    try {
+        ({ OpenAI } = require('openai'));
+    }
+    catch (err) {
+        throw new Error('weflayr.enablePropagateMetadataToGateway: the openai client is required to ' +
+            'call the Weflayr AI gateway. Install it with: npm install openai\n' +
+            `Underlying error: ${err.message}`);
+    }
+    // `prepareOptions` is the openai client's documented hook for mutating a
+    // request's options, and it runs for every endpoint, streaming or not.
+    const originalPrepareOptions = OpenAI.prototype.prepareOptions;
+    if (typeof originalPrepareOptions !== 'function') {
+        throw new Error('weflayr.enablePropagateMetadataToGateway: the openai client has no ' +
+            'prepareOptions hook, so the installed openai version cannot send the ' +
+            'metadata header.');
+    }
+    OpenAI.prototype.prepareOptions = async function prepareOptions(options) {
+        await originalPrepareOptions.call(this, options);
+        addMetadataHeader(this, options);
+    };
+    exports._state.openaiClientsPatched = true;
+    (0, logger_1.debug)('enablePropagateMetadataToGateway: patched the openai client gatewayHostAndPort=%s', exports._state.gatewayHostAndPort ?? exports.PUBLIC_GATEWAY_HOST);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weflayr",
-  "version": "0.26.1",
+  "version": "0.28.0",
   "description": "Weflayr JS/TS SDK — instrument any LLM client",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -13,7 +13,7 @@
     "generate-api": "openapi-ts && node scripts/generate_facade.mjs",
     "pretest": "npm run build",
     "prepublishOnly": "npm run build",
-    "test": "node --test",
+    "test": "node --test \"dist/tests/**/*.test.js\"",
     "lint": "eslint src tests",
     "lint:fix": "eslint src tests --fix",
     "format": "prettier --write src tests",
@@ -31,19 +31,22 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.219.0",
-    "@opentelemetry/instrumentation": "^0.219.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
+    "@opentelemetry/instrumentation": "^0.222.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"
+  },
   "devDependencies": {
     "@hey-api/openapi-ts": "^0.99.0",
     "@opentelemetry/context-async-hooks": "^2.8.0",
     "@types/async-retry": "^1.4.9",
     "@types/node": "^26.1.1",
-    "eslint": "^9.18.0",
+    "eslint": "^10.8.0",
     "prettier": "^3.4.2",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.65.0"

package/dist/src/instrumentation/vercel/full_instrumentation.d.ts

@@ -1,3 +0,0 @@
-export declare class VercelAiSdkInstrumentor {
-    instrument(): void;
-}

package/dist/src/instrumentation/vercel/full_instrumentation.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VercelAiSdkInstrumentor = void 0;
-/**
- * Instrumentor for the Vercel AI SDK (`ai` package, v7+).
- *
- * The AI SDK ships its own OTel integration in `@ai-sdk/otel`; instrumenting
- * is registering it globally so every generateText/streamText/embed call emits
- * GenAI semconv spans through the tracer provider weflayr's setup() installed.
- * `usage: true` adds the `ai.usage.*` token details (reasoning tokens, uncached
- * input) that the semconv attributes do not carry; `providerMetadata: true`
- * opts into `ai.response.providerMetadata` on the spans that carry it.
- *
- * The aggregate spans the integration emits around each model call
- * (invoke_agent, agent_step, duplicated embeddings spans) are filtered out
- * before export by otel/vercel-ai-sdk-span-filter.js.
- */
-const get_cache_creation_telemetry_1 = require("./get_cache_creation_telemetry");
-const get_structured_output_schema_telemetry_1 = require("./get_structured_output_schema_telemetry");
-class VercelAiSdkInstrumentor {
-    instrument() {
-        let registerTelemetry;
-        let OpenTelemetry;
-        try {
-            ({ registerTelemetry } = require('ai'));
-            ({ OpenTelemetry } = require('@ai-sdk/otel'));
-        }
-        catch (err) {
-            throw new Error('weflayr.autoInstrument("vercel_ai_gateway"): failed to load "ai" / "@ai-sdk/otel". ' +
-                `Install them with: npm install ai @ai-sdk/otel\nUnderlying error: ${err.message}`);
-        }
-        // registerTelemetry only exists since v7.
-        if (typeof registerTelemetry !== 'function') {
-            throw new Error('weflayr.autoInstrument("vercel_ai_gateway") requires version 7+ of the Vercel AI SDK ' +
-                '(the "ai" package), which added global telemetry registration. ' +
-                'Upgrade with: npm install ai@latest @ai-sdk/otel.\n' +
-                'On ai <= 6 telemetry can only be enabled per call: remove "vercel_ai_gateway" from ' +
-                'aiSdks (pass an empty list if no other sdks need to be instrumented). Instead, make sure ' +
-                'experimental_telemetry: { isEnabled: true } is passed on each generateText/streamText call.');
-        }
-        const dispatcher = new OpenTelemetry({ usage: true, providerMetadata: true });
-        // The integration never emits the raw provider usage, the only place the
-        // written cache tokens per TTL (Anthropic's `cache_creation`) are
-        // reported; this complement stamps it on the model-call span (see
-        // get_cache_creation_telemetry).
-        new get_cache_creation_telemetry_1.VercelCacheCreationInstrumentor().instrument(dispatcher);
-        // generateObject's schema is only stamped on the root span the weflayr
-        // filter drops; this complement re-stamps it on the model-call span (see
-        // get_structured_output_schema_telemetry).
-        new get_structured_output_schema_telemetry_1.VercelStructuredOutputSchemaInstrumentor().instrument(dispatcher);
-        registerTelemetry(dispatcher);
-    }
-}
-exports.VercelAiSdkInstrumentor = VercelAiSdkInstrumentor;

package/dist/src/instrumentation/vercel/get_cache_creation_telemetry.d.ts

@@ -1,22 +0,0 @@
-/**
- * Cache-write capture for Vercel AI SDK (ai >= 7) model-call spans.
- *
- * Anthropic reports the written cache tokens per TTL in its raw usage
- * (`usage.cache_creation`, ephemeral_5m/1h buckets — billed at different
- * rates). ai >= 7 carries that verbatim on the model-call telemetry event as
- * `event.usage.raw` (a documented field of LanguageModelUsage), but the
- * `@ai-sdk/otel` integration never emits it, so the span loses it.
- *
- * Wrap the telemetry dispatcher's `onLanguageModelCallEnd(event)` (a public
- * callback of the telemetry interface) to read `usage.cache_creation` off the
- * raw usage and stamp it verbatim as `weflayr.cache.creation` on the
- * still-open model-call span (reached through the integration's call state)
- * before the original handler ends it; the normalizer owns the mapping to TTL
- * tiers.
- */
-export declare function cacheCreationFromRawUsage(rawUsage: any): Record<string, unknown> | undefined;
-export declare class VercelCacheCreationInstrumentor {
-    private _patched;
-    instrument(dispatcher: any): void;
-    uninstrument(): void;
-}

package/dist/src/instrumentation/vercel/get_cache_creation_telemetry.js

@@ -1,66 +0,0 @@
-"use strict";
-/**
- * Cache-write capture for Vercel AI SDK (ai >= 7) model-call spans.
- *
- * Anthropic reports the written cache tokens per TTL in its raw usage
- * (`usage.cache_creation`, ephemeral_5m/1h buckets — billed at different
- * rates). ai >= 7 carries that verbatim on the model-call telemetry event as
- * `event.usage.raw` (a documented field of LanguageModelUsage), but the
- * `@ai-sdk/otel` integration never emits it, so the span loses it.
- *
- * Wrap the telemetry dispatcher's `onLanguageModelCallEnd(event)` (a public
- * callback of the telemetry interface) to read `usage.cache_creation` off the
- * raw usage and stamp it verbatim as `weflayr.cache.creation` on the
- * still-open model-call span (reached through the integration's call state)
- * before the original handler ends it; the normalizer owns the mapping to TTL
- * tiers.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VercelCacheCreationInstrumentor = void 0;
-exports.cacheCreationFromRawUsage = cacheCreationFromRawUsage;
-const CACHE_CREATION_ATTR = 'weflayr.cache.creation';
-// The raw `usage.cache_creation` of a provider usage, or undefined when the
-// provider reports none (or reports only zeros — non-caching calls carry no
-// attribute).
-function cacheCreationFromRawUsage(rawUsage) {
-    const cacheCreation = rawUsage && rawUsage.cache_creation;
-    if (!cacheCreation)
-        return undefined;
-    return Object.values(cacheCreation).some(Boolean) ? cacheCreation : undefined;
-}
-class VercelCacheCreationInstrumentor {
-    // [owner, methodName, originalFunction] for uninstrument().
-    _patched = [];
-    // No-op (and never throws) if the interface is missing — the worst case is
-    // the cache-write capture staying empty, exactly the pre-complement
-    // behaviour.
-    instrument(dispatcher) {
-        if (!dispatcher || typeof dispatcher.onLanguageModelCallEnd !== 'function')
-            return;
-        const original = dispatcher.onLanguageModelCallEnd;
-        dispatcher.onLanguageModelCallEnd = function onLanguageModelCallEndWithCacheCreation(event) {
-            try {
-                const cacheCreation = cacheCreationFromRawUsage(event && event.usage && event.usage.raw);
-                if (cacheCreation) {
-                    const callState = this.getCallState && this.getCallState(event.callId);
-                    const span = callState && callState.inferenceSpan;
-                    if (span && typeof span.setAttribute === 'function') {
-                        span.setAttribute(CACHE_CREATION_ATTR, JSON.stringify(cacheCreation));
-                    }
-                }
-            }
-            catch {
-                // Never break span finalization over an enrichment failure.
-            }
-            return original.call(this, event);
-        };
-        this._patched.push([dispatcher, 'onLanguageModelCallEnd', original]);
-    }
-    uninstrument() {
-        for (const [owner, methodName, original] of this._patched) {
-            owner[methodName] = original;
-        }
-        this._patched = [];
-    }
-}
-exports.VercelCacheCreationInstrumentor = VercelCacheCreationInstrumentor;

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

@@ -1,24 +0,0 @@
-/**
- * Structured-output schema capture for Vercel AI SDK (ai >= 7) model-call spans.
- *
- * A `generateObject` call's schema is only ever emitted on the operation's ROOT
- * span (`onObjectOperationStart` stamps `ai.schema` there under the
- * supplemental-attributes opt-in) — and weflayr's span filter drops that
- * aggregate span, keeping one span per model call. So the schema never reaches
- * the exported span, even though the gateway bills it as input.
- *
- * The operation and its nested model call share one `callId` in the
- * dispatcher's call state. Wrap `onObjectOperationStart` to remember the
- * event's schema by callId, and `onObjectStepEnd` — the object operation's own
- * model-call hook, where the call state's `inferenceSpan` exists (object
- * operations never fire `onLanguageModelCallEnd`; verified live) — to stamp it
- * as `ai.schema` on that span, the attribute the worker already reads.
- * `cleanupCallState` is wrapped so an operation that errors before its model
- * call does not leak its entry.
- */
-export declare class VercelStructuredOutputSchemaInstrumentor {
-    private _patched;
-    private _schemasByCallId;
-    instrument(dispatcher: any): void;
-    uninstrument(): void;
-}