weflayr 0.27.0 → 0.28.0

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

@@ -19,6 +19,7 @@ const TRACER_NAME = 'weflayr.instrumentation.cohere_embeddings';
 // Matches the gen_ai.system the cohere chat instrumentors set (Python + Node).
 const SYSTEM = 'Cohere';
 const EMBEDDINGS_OPERATION = 'embeddings';
+const EMBEDDINGS_INPUT_ATTR = 'weflayr.embeddings.input';
 function _recordError(span, error) {
     span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error?.message ?? String(error) });
     span.recordException(error);
@@ -32,13 +33,10 @@ function _wrapEmbed(owner, patched) {
         if (request && request.model) {
             span.setAttribute('gen_ai.request.model', request.model);
         }
-        // The embedded texts are the prompt; stamp one user message per text, like
-        // the chat path. The span processor strips it when content capture is off.
+        // The embedded texts, as passed; the worker shapes them. The span
+        // processor strips the attribute when content capture is off.
         if (request && Array.isArray(request.texts) && request.texts.length) {
-            span.setAttribute('gen_ai.input.messages', JSON.stringify(request.texts.map((text) => ({
-                role: 'user',
-                parts: [{ type: 'text', content: text }],
-            }))));
+            span.setAttribute(EMBEDDINGS_INPUT_ATTR, JSON.stringify(request.texts));
         }
         return Promise.resolve(original.call(this, request, ...rest)).then((response) => {
             // Node SDK reports the billed input tokens under camelCase keys.

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

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * Python wraps the OpenLLMetry instrumentor to stamp this (that instrumentor
+ * covers v2 but records its messages in a shape OTel rejects). The Node
+ * traceloop instrumentor covers only the v1 client, so on this side the shaping
+ * is called by weflayr's own v2 chat instrumentor
+ * (`get_v2_chat_telemetry.ts`) instead.
+ */
+/**
+ * The v2 request's messages in the role+parts shape.
+ *
+ * e.g. `messages=[{role: "user", content: [{type: "text", text: "hi"},
+ * {type: "image_url", image_url: {url: "data:image/png;base64,AAA"}}]}]`
+ * -> `[{role: "user", parts: [{type: "text", content: "hi"},
+ * {type: "blob", mime_type: "image/png"}]}]`.
+ */
+export declare function extractInputMessages(request: unknown): Record<string, unknown>[];

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

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * 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.
+ *
+ * Python wraps the OpenLLMetry instrumentor to stamp this (that instrumentor
+ * covers v2 but records its messages in a shape OTel rejects). The Node
+ * traceloop instrumentor covers only the v1 client, so on this side the shaping
+ * is called by weflayr's own v2 chat instrumentor
+ * (`get_v2_chat_telemetry.ts`) instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractInputMessages = extractInputMessages;
+const get_data_uri_mime_type_1 = require("../../get-data-uri-mime-type");
+function asObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? 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).
+ */
+function getImagePart(block) {
+    // The JS client spells the key imageUrl; the wire (and the Python client)
+    // spell it image_url.
+    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 };
+}
+/**
+ * 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
+ * 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.
+ */
+function contentToParts(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', content }];
+    const parts = [];
+    for (const rawBlock of Array.isArray(content) ? content : []) {
+        const block = asObject(rawBlock);
+        if (block === null)
+            continue;
+        if (block.type === 'text') {
+            parts.push({ type: 'text', content: String(block.text ?? '') });
+        }
+        else if (block.type === 'image_url') {
+            parts.push(getImagePart(block));
+        }
+        else {
+            parts.push({ type: String(block.type ?? 'unknown') });
+        }
+    }
+    return parts;
+}
+/**
+ * An assistant message's `tool_calls` as `tool_call` parts, so an agentic v2
+ * conversation replays with the exchange it was built on.
+ */
+function toolCallsToParts(toolCalls) {
+    const parts = [];
+    for (const rawToolCall of Array.isArray(toolCalls) ? toolCalls : []) {
+        const toolCall = asObject(rawToolCall);
+        if (toolCall === null)
+            continue;
+        const functionCall = asObject(toolCall.function) ?? {};
+        parts.push({
+            type: 'tool_call',
+            id: String(toolCall.id ?? ''),
+            name: String(functionCall.name ?? ''),
+            arguments: functionCall.arguments ?? {},
+        });
+    }
+    return parts;
+}
+/**
+ * The v2 request's messages in the role+parts shape.
+ *
+ * e.g. `messages=[{role: "user", content: [{type: "text", text: "hi"},
+ * {type: "image_url", image_url: {url: "data:image/png;base64,AAA"}}]}]`
+ * -> `[{role: "user", parts: [{type: "text", content: "hi"},
+ * {type: "blob", mime_type: "image/png"}]}]`.
+ */
+function extractInputMessages(request) {
+    const messages = asObject(request)?.messages;
+    const inputMessages = [];
+    for (const rawMessage of Array.isArray(messages) ? messages : []) {
+        const message = asObject(rawMessage);
+        if (message === null)
+            continue;
+        const parts = contentToParts(message.content);
+        parts.push(...toolCallsToParts(message.tool_calls ?? message.toolCalls));
+        inputMessages.push({ role: String(message.role ?? ''), parts });
+    }
+    return inputMessages;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Hand-written OTel instrumentor for the Cohere v2 chat endpoint.
+ *
+ * `@traceloop/instrumentation-cohere` wraps `CohereClient.prototype` only, so a
+ * call made through the v2 client (`CohereClientV2`, the only client that
+ * accepts images) produces no span at all on Node. OpenLLMetry's Python cohere
+ * instrumentor does cover v2, so on that side weflayr only corrects the
+ * messages it records; here weflayr owns the whole span. Both end up producing
+ * the same normalized row.
+ *
+ * Only the non-streaming `chat` is covered: `chatStream` has no span on Node
+ * yet.
+ */
+export declare class CohereV2ChatInstrumentor {
+    private _patched;
+    instrument(): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Hand-written OTel instrumentor for the Cohere v2 chat endpoint.
+ *
+ * `@traceloop/instrumentation-cohere` wraps `CohereClient.prototype` only, so a
+ * call made through the v2 client (`CohereClientV2`, the only client that
+ * accepts images) produces no span at all on Node. OpenLLMetry's Python cohere
+ * instrumentor does cover v2, so on that side weflayr only corrects the
+ * messages it records; here weflayr owns the whole span. Both end up producing
+ * the same normalized row.
+ *
+ * Only the non-streaming `chat` is covered: `chatStream` has no span on Node
+ * yet.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereV2ChatInstrumentor = void 0;
+const api_1 = require("@opentelemetry/api");
+const get_input_message_content_telemetry_1 = require("./get_input_message_content_telemetry");
+const logger_1 = require("../../logger");
+const TRACER_NAME = 'weflayr.instrumentation.cohere_v2_chat';
+// Marks the patched `chat` so a second autoInstrument('cohere') - a new
+// instrumentor instance, and possibly a second copy of this module - does not
+// wrap the wrapper and emit two spans per call.
+const PATCHED_MARKER = Symbol.for('weflayr.cohere.v2.chat.patched');
+// Matches the gen_ai.system the v1 chat instrumentors set (Python + Node).
+const SYSTEM = 'Cohere';
+const CHAT_OPERATION = 'chat';
+function asObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * The response as one assistant message: its content blocks as text parts, the
+ * plan it writes before calling a tool as a reasoning part, and its tool calls
+ * as `tool_call` parts. Mirrors the Python complement's `build_output_messages`.
+ */
+function buildOutputMessages(response) {
+    const message = asObject(asObject(response)?.message);
+    if (message === null)
+        return [];
+    const parts = [];
+    if (message.toolPlan) {
+        parts.push({ type: 'reasoning', content: String(message.toolPlan) });
+    }
+    for (const rawBlock of Array.isArray(message.content) ? message.content : []) {
+        const block = asObject(rawBlock);
+        if (block?.text)
+            parts.push({ type: 'text', content: String(block.text) });
+    }
+    for (const rawToolCall of Array.isArray(message.toolCalls) ? message.toolCalls : []) {
+        const toolCall = asObject(rawToolCall);
+        const functionCall = asObject(toolCall?.function);
+        if (!functionCall?.name)
+            continue;
+        // v2 follows the OpenAI shape: the arguments come as a JSON string.
+        let parsedArguments = functionCall.arguments;
+        if (typeof parsedArguments === 'string') {
+            try {
+                parsedArguments = JSON.parse(parsedArguments);
+            }
+            catch {
+                // A string the model did not close as valid JSON is kept as is.
+            }
+        }
+        const part = {
+            type: 'tool_call',
+            name: String(functionCall.name),
+            arguments: parsedArguments ?? {},
+        };
+        if (toolCall?.id)
+            part.id = String(toolCall.id);
+        parts.push(part);
+    }
+    if (!parts.length)
+        return [];
+    const outputMessage = { role: 'assistant', parts };
+    const finishReason = asObject(response)?.finishReason;
+    if (finishReason)
+        outputMessage.finish_reason = String(finishReason);
+    return [outputMessage];
+}
+function setRequestAttributes(span, request) {
+    const chatRequest = asObject(request);
+    if (chatRequest === null)
+        return;
+    if (chatRequest.model)
+        span.setAttribute('gen_ai.request.model', String(chatRequest.model));
+    // No sampling parameters: OpenLLMetry records none for Cohere either, and a
+    // half-populated input_params would differ between the two SDKs.
+    const inputMessages = (0, get_input_message_content_telemetry_1.extractInputMessages)(chatRequest);
+    if (inputMessages.length) {
+        span.setAttribute('gen_ai.input.messages', JSON.stringify(inputMessages));
+    }
+    if (Array.isArray(chatRequest.tools) && chatRequest.tools.length) {
+        span.setAttribute('gen_ai.tool.definitions', JSON.stringify(chatRequest.tools));
+    }
+}
+function setResponseAttributes(span, response) {
+    const chatResponse = asObject(response);
+    if (chatResponse === null)
+        return;
+    if (chatResponse.id)
+        span.setAttribute('gen_ai.response.id', String(chatResponse.id));
+    if (chatResponse.finishReason) {
+        span.setAttribute('gen_ai.response.finish_reasons', [String(chatResponse.finishReason)]);
+    }
+    const outputMessages = buildOutputMessages(chatResponse);
+    if (outputMessages.length) {
+        span.setAttribute('gen_ai.output.messages', JSON.stringify(outputMessages));
+    }
+    // Cohere reports what it bills under billedUnits; tokens holds the raw counts.
+    const usage = asObject(chatResponse.usage);
+    const billedUnits = asObject(usage?.billedUnits) ?? asObject(usage?.tokens);
+    if (typeof billedUnits?.inputTokens === 'number') {
+        span.setAttribute('gen_ai.usage.input_tokens', billedUnits.inputTokens);
+    }
+    if (typeof billedUnits?.outputTokens === 'number') {
+        span.setAttribute('gen_ai.usage.output_tokens', billedUnits.outputTokens);
+    }
+}
+class CohereV2ChatInstrumentor {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    instrument() {
+        let V2Client;
+        try {
+            // CohereClientV2 binds `chat` as an instance property in its constructor,
+            // so the underlying V2Client class is what has to be patched - and it has
+            // to be patched before the caller builds their client.
+            ({ V2Client } = require('cohere-ai/api/resources/v2/client/Client'));
+        }
+        catch (err) {
+            // A private path inside cohere-ai, so a release can move it. v2 calls
+            // then go uninstrumented, which is what they were before this file: the
+            // v1 client the traceloop instrumentor covers must keep working.
+            (0, logger_1.debug)('cohere: v2 chat not instrumented (%s)', err.message);
+            return;
+        }
+        const original = V2Client.prototype.chat;
+        // Not a function means the release moved or renamed the method: leave v2
+        // uninstrumented rather than install a wrapper whose original.call() would
+        // throw on the caller's first chat.
+        if (typeof original !== 'function' || original[PATCHED_MARKER])
+            return;
+        function wrapper(request, ...rest) {
+            const span = api_1.trace.getTracer(TRACER_NAME).startSpan(CHAT_OPERATION);
+            span.setAttribute('gen_ai.system', SYSTEM);
+            span.setAttribute('gen_ai.operation.name', CHAT_OPERATION);
+            try {
+                setRequestAttributes(span, request);
+            }
+            catch {
+                // Never break the user's Cohere call over an enrichment failure.
+            }
+            return Promise.resolve(original.call(this, request, ...rest)).then((response) => {
+                try {
+                    setResponseAttributes(span, response);
+                }
+                catch {
+                    // As above: the answer still reaches the caller.
+                }
+                span.end();
+                return response;
+            }, (error) => {
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: error?.message ?? String(error),
+                });
+                span.recordException(error);
+                span.end();
+                throw error;
+            });
+        }
+        wrapper[PATCHED_MARKER] = true;
+        V2Client.prototype.chat = wrapper;
+        this._patched.push([V2Client.prototype, 'chat', original]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.CohereV2ChatInstrumentor = CohereV2ChatInstrumentor;

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

@@ -7,7 +7,9 @@
  *   - the embeddings endpoint it doesn't cover,
  *   - the request's structured-output schema, and
  *   - function calling: it records neither the request's tools nor the
- *     response's tool calls.
+ *     response's tool calls, and
+ *   - the v2 chat endpoint, which it does not wrap at all (so a v2 call, the
+ *     only way to send Cohere an image, produced no span).
  */
 export declare class CohereTelemetryInstrumentor {
     private _subInstrumentors;

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

@@ -8,7 +8,9 @@
  *   - the embeddings endpoint it doesn't cover,
  *   - the request's structured-output schema, and
  *   - function calling: it records neither the request's tools nor the
- *     response's tool calls.
+ *     response's tool calls, and
+ *   - the v2 chat endpoint, which it does not wrap at all (so a v2 call, the
+ *     only way to send Cohere an image, produced no span).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CohereTelemetryInstrumentor = void 0;
@@ -18,6 +20,7 @@ const get_embeddings_telemetry_1 = require("./get_embeddings_telemetry");
 const get_structured_output_schema_telemetry_2 = require("./get_structured_output_schema_telemetry");
 const get_tool_call_output_telemetry_1 = require("./get_tool_call_output_telemetry");
 const get_tool_definitions_telemetry_1 = require("./get_tool_definitions_telemetry");
+const get_v2_chat_telemetry_1 = require("./get_v2_chat_telemetry");
 class CohereTelemetryInstrumentor {
     _subInstrumentors;
     constructor() {
@@ -27,6 +30,7 @@ class CohereTelemetryInstrumentor {
             new get_structured_output_schema_telemetry_1.TraceloopStructuredOutputSchemaInstrumentor(get_structured_output_schema_telemetry_2.readStructuredOutputSchema),
             new get_tool_definitions_telemetry_1.CohereToolDefinitionsInstrumentor(),
             new get_tool_call_output_telemetry_1.CohereToolCallOutputInstrumentor(),
+            new get_v2_chat_telemetry_1.CohereV2ChatInstrumentor(),
         ];
     }
     instrument(instrumentation) {

package/dist/src/instrumentation/google/get_embeddings_telemetry.d.ts

@@ -4,9 +4,13 @@
  * `@traceloop/instrumentation-google-generativeai` wraps generate_content but not
  * embeddings, so this covers it by starting its own span on the private
  * `Models.prototype.embedContentInternal` (which the public `embedContent`
- * delegates to). The Gemini Developer API returns NO token usage on embedContent
- * (only Vertex does), so the span records the billable unit weflayr can price:
- * the input character count under `gen_ai.usage.input_characters` (normalized to
- * num_input_chars).
+ * delegates to).
+ *
+ * Both surfaces bill embeddings per input token, and only Vertex reports them:
+ * it returns `tokenCount` in each embedding's `statistics`, which the span
+ * records as `gen_ai.usage.input_tokens`. The Gemini Developer API returns no
+ * usage at all, on any API version, so its calls carry no token attribute and
+ * weflayr cannot price them, which `_warnDeveloperApiUnpriced` says once per
+ * process.
  */
 export declare function instrumentEmbeddings(Models: any, patched: [any, string, any][]): void;

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

@@ -5,10 +5,14 @@
  * `@traceloop/instrumentation-google-generativeai` wraps generate_content but not
  * embeddings, so this covers it by starting its own span on the private
  * `Models.prototype.embedContentInternal` (which the public `embedContent`
- * delegates to). The Gemini Developer API returns NO token usage on embedContent
- * (only Vertex does), so the span records the billable unit weflayr can price:
- * the input character count under `gen_ai.usage.input_characters` (normalized to
- * num_input_chars).
+ * delegates to).
+ *
+ * Both surfaces bill embeddings per input token, and only Vertex reports them:
+ * it returns `tokenCount` in each embedding's `statistics`, which the span
+ * records as `gen_ai.usage.input_tokens`. The Gemini Developer API returns no
+ * usage at all, on any API version, so its calls carry no token attribute and
+ * weflayr cannot price them, which `_warnDeveloperApiUnpriced` says once per
+ * process.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.instrumentEmbeddings = instrumentEmbeddings;
@@ -16,34 +20,59 @@ const api_1 = require("@opentelemetry/api");
 const get_provider_name_1 = require("./get_provider_name");
 const TRACER_NAME = 'weflayr.instrumentation.google.embeddings';
 const EMBEDDINGS_OPERATION = 'embeddings';
-// `contents` is a string, a Content/Part object, or an array of those; the
-// billable unit is the total number of characters of text across them.
-function _contentCharacters(contents) {
+const EMBEDDINGS_INPUT_ATTR = 'weflayr.embeddings.input';
+const GEMINI_DEVELOPER_API_SYSTEM = 'gemini';
+// The Gemini Developer API reports no embeddings usage, so those calls are
+// stored with a cost of zero; say so once rather than let that pass silently.
+let _developerApiWarningSaid = false;
+// One embedded content is a string, a Content/Part object, or an array of
+// those (a Content's parts); its text is the concatenation across them.
+function _contentText(content) {
+    if (content == null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content))
+        return content.map(_contentText).join('');
+    if (typeof content.text === 'string')
+        return content.text;
+    return _contentText(content.parts);
+}
+// The text of each embedded content, e.g. ["ab", "cde"] for
+// contents: ["ab", { parts: [{ text: "cde" }] }].
+function _embeddedTexts(contents) {
     if (contents == null)
-        return 0;
-    if (typeof contents === 'string')
-        return contents.length;
-    if (Array.isArray(contents)) {
-        return contents.reduce((total, item) => total + _contentCharacters(item), 0);
-    }
-    if (typeof contents === 'object') {
-        if (typeof contents.text === 'string')
-            return contents.text.length;
-        if (Array.isArray(contents.parts))
-            return _contentCharacters(contents.parts);
-    }
-    return 0;
+        return [];
+    const contentsList = Array.isArray(contents) ? contents : [contents];
+    return contentsList.map(_contentText);
 }
-// The embedded text mapped to the role+parts message shape the chat path uses:
-// a string (or {text} / {parts} object) becomes one user message per content.
-function _contentToMessage(content) {
-    if (typeof content === 'string') {
-        return { role: 'user', parts: [{ type: 'text', content }] };
+// Says once per process that Gemini Developer API embeddings calls cannot be
+// priced.
+function _warnDeveloperApiUnpriced() {
+    if (_developerApiWarningSaid)
+        return;
+    _developerApiWarningSaid = true;
+    console.warn('weflayr: Gemini Developer API embeddings calls cannot be priced: the API ' +
+        'returns no token usage for them, so they are recorded with a cost of ' +
+        'zero. Use Vertex, which reports the token count itself.');
+}
+// Records the input tokens Vertex reports per embedding, e.g. 7 for a call
+// embedding two texts of 2 and 5 tokens. The Gemini Developer API reports none,
+// and then the span carries no token attribute.
+function _recordInputTokens(span, response) {
+    try {
+        const reported = ((response && response.embeddings) || []).map((embedding) => embedding && embedding.statistics && embedding.statistics.tokenCount);
+        // A total is only worth recording when every embedding reports a number:
+        // one missing or unreadable count would make the sum too small.
+        if (reported.length && reported.every((tokenCount) => Number.isFinite(tokenCount))) {
+            span.setAttribute('gen_ai.usage.input_tokens', reported.reduce((total, tokenCount) => total + tokenCount, 0));
+        }
     }
-    if (content && typeof content.text === 'string') {
-        return { role: 'user', parts: [{ type: 'text', content: content.text }] };
+    catch (error) {
+        // Telemetry must never break the app's call, and a swallowed failure still
+        // has to be findable.
+        console.debug('weflayr: reading Gemini embeddings usage failed', error);
     }
-    return { role: 'user', parts: [] };
 }
 function _recordError(span, error) {
     span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error?.message ?? String(error) });
@@ -58,20 +87,24 @@ function instrumentEmbeddings(Models, patched) {
         return;
     function wrapper(params, ...rest) {
         const span = api_1.trace.getTracer(TRACER_NAME).startSpan(EMBEDDINGS_OPERATION);
-        span.setAttribute('gen_ai.system', (0, get_provider_name_1.getProviderName)(this));
+        const system = (0, get_provider_name_1.getProviderName)(this);
+        span.setAttribute('gen_ai.system', system);
         span.setAttribute('gen_ai.operation.name', EMBEDDINGS_OPERATION);
         if (params && params.model) {
             // The chat path strips the leading "models/" prefix; mirror it.
             span.setAttribute('gen_ai.request.model', params.model.replace(/^models\//, ''));
         }
-        span.setAttribute('gen_ai.usage.input_characters', _contentCharacters(params && params.contents));
-        // The embedded text is the prompt; stamp it like the chat path does. The
-        // span processor strips it when message-content capture is disabled.
-        if (params && params.contents != null) {
-            const contentsList = Array.isArray(params.contents) ? params.contents : [params.contents];
-            span.setAttribute('gen_ai.input.messages', JSON.stringify(contentsList.map(_contentToMessage)));
+        const embeddedTexts = _embeddedTexts(params && params.contents);
+        // The embedded texts; the worker shapes them. The span processor strips
+        // the attribute when message-content capture is disabled.
+        if (embeddedTexts.length) {
+            span.setAttribute(EMBEDDINGS_INPUT_ATTR, JSON.stringify(embeddedTexts));
+        }
+        if (system === GEMINI_DEVELOPER_API_SYSTEM) {
+            _warnDeveloperApiUnpriced();
         }
         return Promise.resolve(original.call(this, params, ...rest)).then((response) => {
+            _recordInputTokens(span, response);
             span.end();
             return response;
         }, (error) => {

package/dist/src/instrumentation/google/get_provider_name.d.ts

@@ -6,6 +6,7 @@
  * Developer API. We read the client's Vertex flag and return the value to set as
  * `gen_ai.system` (which the normalizer prefers): `vertex_ai` / `gemini`,
  * matching what the Python google-genai instrumentor reports natively. The
- * worker normalizes `vertex_ai` to the canonical `vertex`. Node-only.
+ * worker normalizes `gemini` to the canonical `google` and `vertex_ai` to
+ * `vertex`. Node-only.
  */
 export declare function getProviderName(instance: any): string;

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

@@ -7,7 +7,8 @@
  * Developer API. We read the client's Vertex flag and return the value to set as
  * `gen_ai.system` (which the normalizer prefers): `vertex_ai` / `gemini`,
  * matching what the Python google-genai instrumentor reports natively. The
- * worker normalizes `vertex_ai` to the canonical `vertex`. Node-only.
+ * worker normalizes `gemini` to the canonical `google` and `vertex_ai` to
+ * `vertex`. Node-only.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProviderName = getProviderName;

package/dist/src/instrumentation/google/get_web_search_telemetry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Provider-run web search (Google Search grounding) capture for Gemini spans.
+ *
+ * Gemini runs the search itself when the request config carries the
+ * `googleSearch` tool, and bills the call once per grounded request whatever
+ * number of queries it ran. Neither instrumentor records any of it: the
+ * `googleSearch` tool is nowhere in the span, `candidates[].groundingMetadata`
+ * is dropped, and so is `usageMetadata.toolUsePromptTokenCount`, input tokens
+ * the call is billed for, counted SEPARATELY from `promptTokenCount`, so a
+ * 14-token prompt that grounds bills 14 + 65.
+ *
+ * All three are stamped under `weflayr.web_search.*`; `normalizers/google.py`
+ * maps them to the shape every provider's web search is stored in.
+ *
+ * The `@google/genai` client answers in camelCase where the Python one answers
+ * in snake_case, so the stamped JSON is written in snake_case: both SDKs must
+ * produce the same event for the same call, and the normalizer reads one
+ * spelling.
+ *
+ * `groundingMetadata.searchEntryPoint` is not stamped: it is several kilobytes
+ * of styled HTML for rendering Google's "Search suggestions" widget, which
+ * nothing reads back.
+ */
+/** The request's Google Search tools, as configured, under the names the Python
+ * SDK stamps. e.g. a config carrying `{ tools: [{ googleSearch: {} }] }` ->
+ * `[{ google_search: {} }]`, and one setting a time range ->
+ * `[{ google_search: { time_range_filter: {...} } }]`. */
+export declare function extractWebSearchToolDefinitions(config: any): any[];
+export declare function setWebSearchToolTelemetry(span: any, config: any): void;
+/** The queries and pages of a grounded candidate, in the snake_case shape the
+ * normalizer reads. Returns an empty array when nothing was grounded. */
+export declare function extractGroundingBlocks(response: any): any[];
+/** Stamp what the grounded answer searched for, that it is billed for one
+ * grounded request, and the input tokens the search results added.
+ *
+ * Over a stream each chunk re-reports the grounding gathered so far, so the
+ * attribute is re-stamped rather than accumulated. */
+export declare function setWebSearchResultTelemetry(span: any, response: any): void;