weflayr 0.21.0 → 0.22.1

package/src/api/index.ts

@@ -0,0 +1,45 @@
+/**
+ * Entry point for the Weflayr public API (revenue, key metrics, customer tags).
+ *
+ * The endpoint functions and types under ./generated are produced from the
+ * platform's OpenAPI spec (`make generate-sdk-api-clients`) and speak the
+ * wire's snake_case, same as the Python SDK. generated/facade.gen.ts (also
+ * produced by that command, via scripts/generate_facade.mjs) wraps every
+ * endpoint so JS callers use camelCase instead - see ./caseConversion and
+ * ./makeEndpoint. This module is the handwritten front door that configures
+ * their client:
+ *
+ *     const weflayr = require('weflayr');
+ *
+ *     const apiClient = weflayr.client({ apiKey: 'wf-...' });
+ *     const { data } = await weflayr.api.getAllRevenue({ client: apiClient, throwOnError: true });
+ */
+
+import { type Client, createClient, createConfig } from './generated/client';
+
+export const DEFAULT_BASE_URL = 'https://app.weflayr.com/api';
+
+export interface ApiClientOptions {
+  /** A project API key, created in the Weflayr dashboard. Defaults to the `WEFLAYR_API_KEY` environment variable. */
+  apiKey?: string;
+  /** Where the API lives — override for local or self-hosted deployments. */
+  baseUrl?: string;
+}
+
+/** A client for the public API, authenticated with a project API key. */
+export function client(options: ApiClientOptions = {}): Client {
+  const apiKey = options.apiKey || process.env.WEFLAYR_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      'weflayr.client: `apiKey` is required (pass it explicitly or set WEFLAYR_API_KEY)'
+    );
+  }
+  return createClient(
+    createConfig({
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+      auth: () => apiKey,
+    })
+  );
+}
+
+export * from './generated/facade.gen';

package/src/api/makeEndpoint.ts

@@ -0,0 +1,54 @@
+/**
+ * Wraps a generated public-API endpoint function so its `body`/`path`/`query`
+ * are converted from camelCase to the wire's snake_case on the way out, and
+ * its `data`/`error` are converted back to camelCase on the way in.
+ *
+ * Instantiated once per endpoint in generated/facade.gen.ts, produced by
+ * scripts/generate_facade.mjs - see that script for how the per-endpoint
+ * type arguments are derived.
+ */
+
+import { toCamelCaseDeep, toSnakeCaseDeep } from './caseConversion';
+import type { Client } from './generated/client';
+
+export interface ClientOption {
+  client: Client;
+  throwOnError?: boolean;
+  headers?: HeadersInit;
+}
+
+export interface CallResult<TData, TError> {
+  data?: TData;
+  error?: TError;
+  request?: Request;
+  response?: Response;
+}
+
+type WireResult = { data?: unknown; error?: unknown };
+
+export function makeEndpoint<TParams extends object, TData, TError>(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  wireFn: (options: any) => Promise<WireResult>
+): (options: ClientOption & TParams) => Promise<CallResult<TData, TError>> {
+  return async (options) => {
+    const wireOptions = { ...options } as Record<string, unknown>;
+    for (const key of ['body', 'path', 'query']) {
+      if (wireOptions[key] !== undefined) {
+        wireOptions[key] = toSnakeCaseDeep(wireOptions[key]);
+      }
+    }
+
+    let result: WireResult;
+    try {
+      result = await wireFn(wireOptions);
+    } catch (error) {
+      throw toCamelCaseDeep(error as object);
+    }
+
+    return {
+      ...result,
+      data: result.data !== undefined ? (toCamelCaseDeep(result.data) as TData) : undefined,
+      error: result.error !== undefined ? (toCamelCaseDeep(result.error) as TError) : undefined,
+    };
+  };
+}

package/src/auto-instrument.js

@@ -12,16 +12,24 @@ const AiSdk = Object.freeze({
   COHERE: 'cohere',
   GOOGLE_GENAI: 'google-genai',
   ELEVENLABS: 'elevenlabs',
+  VERCEL_AI_GATEWAY: 'vercel_ai_gateway',
 });
 
-// Allowed values for `propagateMetadata({ providerName })`: every SDK the
-// auto-instrumentation registry knows, plus providers reached via the OpenAI
-// SDK on the wire but reported as themselves
-// Those are instrumented via `autoInstrument({ aiSdks: 'openai' })` and labelled
-// through `propagateMetadata({ providerName })`, not their own instrumentor.
+// Allowed values for `propagateMetadata({ providerName })`: 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 labelled gemini or vertex,
+// and mistral has no Node OTel instrumentor so it is reached through the
+// OpenAI SDK (OpenAI-compatible endpoint) but reported as itself.
 const AIProviderName = Object.freeze({
-  ...AiSdk,
+  OPENAI: 'openai',
+  ANTHROPIC: 'anthropic',
+  BEDROCK: 'bedrock',
+  COHERE: 'cohere',
+  ELEVENLABS: 'elevenlabs',
+  MISTRAL: 'mistral',
   VERCEL_AI_GATEWAY: 'vercel_ai_gateway',
+  GEMINI: 'gemini',
+  VERTEX: 'vertex',
 });
 
 // The primary instrumentor for each provider SDK. Most are third-party
@@ -40,6 +48,11 @@ const REGISTRY = {
     requirePath: './instrumentation/elevenlabs/full_instrumentation',
     className: 'ElevenLabsInstrumentor',
   },
+  [AiSdk.VERCEL_AI_GATEWAY]: {
+    package: 'ai',
+    requirePath: './instrumentation/vercel/full_instrumentation',
+    className: 'VercelAiSdkInstrumentor',
+  },
 };
 
 // One complementary instrumentor per provider: a `set_telemetry_attributes`

package/src/index.js

@@ -3,6 +3,9 @@
 const { setup, flush } = require('./setup');
 const { autoInstrument, AiSdk, AIProviderName } = require('./auto-instrument');
 const { propagateMetadata } = require('./otel/propagation');
+// Public-API client (revenue, key metrics, customer tags), compiled from the
+// TypeScript in src/api by `npm run build`.
+const api = require('../dist/api');
 
 module.exports = {
   setup,
@@ -11,4 +14,6 @@ module.exports = {
   AiSdk,
   AIProviderName,
   propagateMetadata,
+  client: api.client,
+  api,
 };

package/src/instrumentation/anthropic/get_streaming_stop_reason_telemetry.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * Streamed stop-reason enrichment for the Anthropic chat span.
+ *
+ * `@traceloop/instrumentation-anthropic` accumulates a streamed response into a
+ * result object but never reads the `message_delta` chunk's `delta.stop_reason`,
+ * so streamed spans format their output message with an empty `finish_reason`.
+ *
+ * `_streamingWrapPromise(client, moduleExports, { span, type, promise })`
+ * returns `new moduleExports.APIPromise(...)` whose parse step wraps the real
+ * SDK stream with the instrumentor's accumulating iterator. This complement
+ * hands it a patched `moduleExports` whose APIPromise interposes on that parse
+ * step, observing the chunks (outside the accumulating iterator, so every chunk
+ * is seen before the iterator finishes) to capture the stop reason — which is
+ * then injected into the accumulated result just before `_endSpan` formats the
+ * output message.
+ */
+
+class AnthropicStreamingStopReasonInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+    // span -> stop_reason captured from the stream's message_delta chunk.
+    this._stopReasonBySpan = new WeakMap();
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is an empty streamed finish_reason, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+
+    const stopReasonBySpan = this._stopReasonBySpan;
+
+    async function* observeStopReason(stream, span) {
+      for await (const chunk of stream) {
+        try {
+          if (
+            chunk &&
+            chunk.type === 'message_delta' &&
+            chunk.delta &&
+            chunk.delta.stop_reason != null
+          ) {
+            stopReasonBySpan.set(span, chunk.delta.stop_reason);
+          }
+        } catch {
+          // Never break the caller's stream over an enrichment failure.
+        }
+        yield chunk;
+      }
+    }
+
+    const streamOriginal = instrumentation._streamingWrapPromise;
+    if (typeof streamOriginal === 'function') {
+      instrumentation._streamingWrapPromise = function streamWithStopReason(
+        client,
+        moduleExports,
+        opts
+      ) {
+        const span = opts && opts.span;
+        if (!span || !moduleExports || typeof moduleExports.APIPromise !== 'function') {
+          return streamOriginal.call(this, client, moduleExports, opts);
+        }
+        class APIPromiseWithStopReason extends moduleExports.APIPromise {
+          constructor(promiseClient, responsePromise, parseResponse) {
+            super(promiseClient, responsePromise, async (parseClient, props) => {
+              const stream = await parseResponse(parseClient, props);
+              try {
+                if (
+                  stream &&
+                  typeof stream[Symbol.asyncIterator] === 'function' &&
+                  typeof stream.constructor === 'function'
+                ) {
+                  return new stream.constructor(
+                    () => observeStopReason(stream, span),
+                    stream.controller
+                  );
+                }
+              } catch {
+                // Fall through to the unobserved stream.
+              }
+              return stream;
+            });
+          }
+        }
+        // The SDK's module exports are non-writable, so the override is an own
+        // defined property shadowing the inherited one.
+        const patchedModuleExports = Object.create(moduleExports, {
+          APIPromise: { value: APIPromiseWithStopReason, configurable: true },
+        });
+        return streamOriginal.call(this, client, patchedModuleExports, opts);
+      };
+      this._patched.push([instrumentation, '_streamingWrapPromise', streamOriginal]);
+    }
+
+    const endSpanOriginal = instrumentation._endSpan;
+    if (typeof endSpanOriginal === 'function') {
+      instrumentation._endSpan = function endSpanWithStopReason(args) {
+        try {
+          const captured = args && args.span && stopReasonBySpan.get(args.span);
+          if (captured != null && args.result && args.result.stop_reason == null) {
+            args.result.stop_reason = captured;
+          }
+        } catch {
+          // Never break span finalization over an enrichment failure.
+        }
+        return endSpanOriginal.call(this, args);
+      };
+      this._patched.push([instrumentation, '_endSpan', endSpanOriginal]);
+    }
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { AnthropicStreamingStopReasonInstrumentor };

package/src/instrumentation/anthropic/get_tool_definitions_telemetry.js

@@ -0,0 +1,50 @@
+'use strict';
+
+/**
+ * Tool-definitions enrichment for the Anthropic chat span.
+ *
+ * `@traceloop/instrumentation-anthropic` records the request model/temperature
+ * attributes in `startSpan({ type, params })` but never the request's `tools`,
+ * so tool-using calls carry no `gen_ai.tool.definitions`. Wrap `startSpan` to
+ * stamp them in the same `{name, description, input_schema}` shape the request
+ * uses. The span processor strips the attribute when message-content capture is
+ * disabled.
+ */
+
+class AnthropicToolDefinitionsInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is missing tool definitions, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+    const startSpanOriginal = instrumentation.startSpan;
+    if (typeof startSpanOriginal !== 'function') return;
+
+    instrumentation.startSpan = function startSpanWithToolDefinitions(request) {
+      const span = startSpanOriginal.call(this, request);
+      try {
+        const tools = request && request.params && request.params.tools;
+        if (Array.isArray(tools) && tools.length) {
+          span.setAttribute('gen_ai.tool.definitions', JSON.stringify(tools));
+        }
+      } catch {
+        // Never break span creation over an enrichment failure.
+      }
+      return span;
+    };
+    this._patched.push([instrumentation, 'startSpan', startSpanOriginal]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { AnthropicToolDefinitionsInstrumentor };

package/src/instrumentation/anthropic/set_telemetry_attributes.js

@@ -3,16 +3,26 @@
 /**
  * Anthropic telemetry complement — the registered orchestrator.
  *
- * Wires the one weflayr-supplied patch the traceloop Anthropic instrumentor
+ * Wires the weflayr-supplied patches the traceloop Anthropic instrumentor
  * misses: cached-prompt token counts on the chat span (it reads them off the
- * response but writes no `gen_ai.usage.cache_*` attribute).
+ * response but writes no `gen_ai.usage.cache_*` attribute), the request's tool
+ * definitions, and the streamed stop reason (its stream accumulator drops it,
+ * leaving an empty finish_reason on the output message).
  */
 
 const { AnthropicPromptCachingInstrumentor } = require('./get_cache_and_reasoning_telemetry');
+const {
+  AnthropicStreamingStopReasonInstrumentor,
+} = require('./get_streaming_stop_reason_telemetry');
+const { AnthropicToolDefinitionsInstrumentor } = require('./get_tool_definitions_telemetry');
 
 class AnthropicTelemetryInstrumentor {
   constructor() {
-    this._subInstrumentors = [new AnthropicPromptCachingInstrumentor()];
+    this._subInstrumentors = [
+      new AnthropicPromptCachingInstrumentor(),
+      new AnthropicStreamingStopReasonInstrumentor(),
+      new AnthropicToolDefinitionsInstrumentor(),
+    ];
   }
 
   instrument(instrumentation) {

package/src/instrumentation/bedrock/get_input_message_content_telemetry.js

@@ -0,0 +1,94 @@
+'use strict';
+
+/**
+ * Input message content for Bedrock invoke_model spans the instrumentor misses.
+ *
+ * `@traceloop/instrumentation-bedrock` parses the request body per model vendor,
+ * so a call whose model id has no recognizable vendor (e.g. an invalid model —
+ * exactly the error spans) gets no `gen_ai.input.messages`. Wrap the
+ * instrumentor's `_startSpan({ params })` to stamp the input messages from the
+ * request body whenever the instrumentor did not. The span processor strips the
+ * attribute when message-content capture is disabled.
+ */
+
+function _contentToParts(content) {
+  if (typeof content === 'string') {
+    return [{ type: 'text', content }];
+  }
+  if (Array.isArray(content)) {
+    return content
+      .filter((block) => block && typeof block.text === 'string')
+      .map((block) => ({ type: 'text', content: block.text }));
+  }
+  return [];
+}
+
+// Messages in the role+parts shape from an InvokeModel JSON body — the
+// `messages` schema (Nova, Anthropic-on-Bedrock) or the flat `inputText` /
+// `prompt` schemas (Titan, legacy).
+function _inputMessagesFromRequestBody(rawBody) {
+  if (typeof rawBody !== 'string') return [];
+  let body;
+  try {
+    body = JSON.parse(rawBody);
+  } catch {
+    return [];
+  }
+  if (!body || typeof body !== 'object') return [];
+  if (Array.isArray(body.messages)) {
+    return body.messages
+      .filter((message) => message && typeof message === 'object')
+      .map((message) => ({
+        role: String(message.role || ''),
+        parts: _contentToParts(message.content),
+      }));
+  }
+  const prompt = body.inputText || body.prompt;
+  if (typeof prompt === 'string') {
+    return [{ role: 'user', parts: [{ type: 'text', content: prompt }] }];
+  }
+  return [];
+}
+
+class BedrockInputMessageContentInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is missing input messages, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+    const original = instrumentation._startSpan;
+    if (typeof original !== 'function') return;
+
+    instrumentation._startSpan = function startSpanWithInputMessages(request) {
+      const span = original.call(this, request);
+      try {
+        const attributes = span && span.attributes;
+        if (attributes && attributes['gen_ai.input.messages'] == null) {
+          const body =
+            request && request.params && request.params.input && request.params.input.body;
+          const messages = _inputMessagesFromRequestBody(body);
+          if (messages.length) {
+            span.setAttribute('gen_ai.input.messages', JSON.stringify(messages));
+          }
+        }
+      } catch {
+        // Never break span creation over an enrichment failure.
+      }
+      return span;
+    };
+    this._patched.push([instrumentation, '_startSpan', original]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { BedrockInputMessageContentInstrumentor };

package/src/instrumentation/bedrock/get_streaming_output_message_telemetry.js

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * Streamed-output message content for the Bedrock invoke_model stream span.
+ *
+ * `@traceloop/instrumentation-bedrock` accumulates the streamed text but formats
+ * the final `gen_ai.output.messages` by passing that string through its chat
+ * block mapper, which only accepts block arrays — so streamed Nova spans end up
+ * with an assistant message whose `parts` is empty. This complement wraps the
+ * instrumentor's per-chunk `_handleNovaStreamingMetadata(span, parsedResponse)`
+ * hook: it accumulates the `contentBlockDelta` text and the `messageStop` stop
+ * reason itself, and re-stamps a correct output message when the trailing
+ * `metadata` chunk (always last in a Nova stream) arrives — after the
+ * instrumentor has written its empty-parts message. The span processor strips
+ * the attribute when message-content capture is disabled.
+ */
+
+// Nova stop reasons mapped to the OTel finish_reason values the instrumentor
+// uses on non-streamed spans, so streamed and non-streamed rows normalize alike.
+const FINISH_REASON_BY_STOP_REASON = {
+  end_turn: 'stop',
+  stop_sequence: 'stop',
+  max_tokens: 'length',
+  tool_use: 'tool_call',
+};
+
+class BedrockStreamingOutputMessageInstrumentor {
+  constructor() {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    this._patched = [];
+    // span -> {text, stopReason} accumulated across the stream's chunks.
+    this._streamStateBySpan = new WeakMap();
+  }
+
+  // No-op (and never throws) if the instrumentor's internals have changed shape —
+  // the worst case is an empty streamed output message, never a crash.
+  instrument(instrumentation) {
+    if (!instrumentation) return;
+    const original = instrumentation._handleNovaStreamingMetadata;
+    if (typeof original !== 'function') return;
+
+    const streamStateBySpan = this._streamStateBySpan;
+    instrumentation._handleNovaStreamingMetadata = function handleWithOutputMessage(
+      span,
+      parsedResponse
+    ) {
+      try {
+        const state = streamStateBySpan.get(span) || { text: '', stopReason: null };
+        const delta =
+          parsedResponse &&
+          parsedResponse.contentBlockDelta &&
+          parsedResponse.contentBlockDelta.delta &&
+          parsedResponse.contentBlockDelta.delta.text;
+        if (typeof delta === 'string') state.text += delta;
+        const stopReason =
+          parsedResponse && parsedResponse.messageStop && parsedResponse.messageStop.stopReason;
+        if (stopReason != null) state.stopReason = stopReason;
+        streamStateBySpan.set(span, state);
+
+        if (parsedResponse && parsedResponse.metadata && state.text) {
+          const message = {
+            role: 'assistant',
+            parts: [{ type: 'text', content: state.text }],
+          };
+          if (state.stopReason != null) {
+            message.finish_reason =
+              FINISH_REASON_BY_STOP_REASON[state.stopReason] || state.stopReason;
+          }
+          span.setAttribute('gen_ai.output.messages', JSON.stringify([message]));
+        }
+      } catch {
+        // Never break the caller's stream over an enrichment failure.
+      }
+      return original.call(this, span, parsedResponse);
+    };
+    this._patched.push([instrumentation, '_handleNovaStreamingMetadata', original]);
+  }
+
+  uninstrument() {
+    for (const [owner, methodName, original] of this._patched) {
+      owner[methodName] = original;
+    }
+    this._patched = [];
+  }
+}
+
+module.exports = { BedrockStreamingOutputMessageInstrumentor };

package/src/instrumentation/bedrock/set_telemetry_attributes.js

@@ -3,16 +3,25 @@
 /**
  * Bedrock telemetry complement — the registered orchestrator.
  *
- * Wires the one weflayr-supplied patch the traceloop Bedrock instrumentor misses:
+ * Wires the weflayr-supplied patches the traceloop Bedrock instrumentor misses:
  * cached-prompt token counts on the invoke_model span (Nova returns them in the
- * response body but traceloop never reads them).
+ * response body but traceloop never reads them) and the streamed output message
+ * content (its stream path formats an empty-parts message).
  */
 
 const { BedrockPromptCachingInstrumentor } = require('./get_cache_telemetry');
+const { BedrockInputMessageContentInstrumentor } = require('./get_input_message_content_telemetry');
+const {
+  BedrockStreamingOutputMessageInstrumentor,
+} = require('./get_streaming_output_message_telemetry');
 
 class BedrockTelemetryInstrumentor {
   constructor() {
-    this._subInstrumentors = [new BedrockPromptCachingInstrumentor()];
+    this._subInstrumentors = [
+      new BedrockPromptCachingInstrumentor(),
+      new BedrockInputMessageContentInstrumentor(),
+      new BedrockStreamingOutputMessageInstrumentor(),
+    ];
   }
 
   instrument(instrumentation) {

package/src/instrumentation/cohere/get_embeddings_telemetry.js

@@ -36,6 +36,16 @@ 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.
+    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 }] }))
+        )
+      );
+    }
     return Promise.resolve(original.call(this, request, ...rest)).then(
       (response) => {
         // Node SDK reports the billed input tokens under camelCase keys.

package/src/instrumentation/google/get_audio_telemetry.js

@@ -5,8 +5,7 @@
  *
  * Neither instrumentor breaks usage down by modality, so for audio in/out (e.g.
  * Gemini TTS) we read the response's per-modality token details and set
- * `gen_ai.usage.{input,output}_tokens_details.audio_tokens` (normalized to
- * token_audio_input / token_audio_output).
+ * `gen_ai.usage.{input,output}_tokens_details.audio_tokens`.
  */
 
 // Sum the token counts whose modality is AUDIO across a *TokensDetails array.

package/src/instrumentation/google/get_cache_telemetry.js

@@ -6,9 +6,7 @@
  * Neither instrumentor records cached-content tokens, so we read
  * `usageMetadata.cachedContentTokenCount` (explicit or implicit caching) and
  * split it by modality: audio cached tokens go to
- * `gen_ai.usage.input_tokens_details.cached_audio_tokens` (normalized to
- * token_audio_cached) and the remainder to `gen_ai.usage.cache_read_input_tokens`
- * (normalized to token_text_cached).
+ * `gen_ai.usage.input_tokens_details.cached_audio_tokens`and the remainder to `gen_ai.usage.cache_read_input_tokens`
  */
 
 const { _audioTokens } = require('./get_audio_telemetry');

package/src/instrumentation/google/get_embeddings_telemetry.js

@@ -9,7 +9,7 @@
  * 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
- * count_char).
+ * num_input_chars).
  */
 
 const { trace, SpanStatusCode } = require('@opentelemetry/api');
@@ -34,6 +34,18 @@ function _contentCharacters(contents) {
   return 0;
 }
 
+// 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 }] };
+  }
+  if (content && typeof content.text === 'string') {
+    return { role: 'user', parts: [{ type: 'text', content: content.text }] };
+  }
+  return { role: 'user', parts: [] };
+}
+
 function _recordError(span, error) {
   span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message ?? String(error) });
   span.recordException(error);
@@ -58,6 +70,15 @@ function instrumentEmbeddings(Models, patched) {
       '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))
+      );
+    }
     return Promise.resolve(original.call(this, params, ...rest)).then(
       (response) => {
         span.end();

package/src/instrumentation/google/get_provider_name.js

@@ -7,7 +7,8 @@
  * `gen_ai.provider.name = "gcp.gen_ai"` and can't tell Vertex from the Gemini
  * 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. Node-only.
+ * matching what the Python google-genai instrumentor reports natively. The
+ * worker normalizes `vertex_ai` to the canonical `vertex`. Node-only.
  */
 
 // Read the Vertex-vs-Dev backend off the Models instance's api client.