weflayr 0.27.0 → 0.29.0

package/dist/src/instrumentation/bedrock/get_cache_config_telemetry.d.ts

@@ -1,5 +1,6 @@
 /**
- * Request-side prompt-caching config capture for Bedrock invoke_model spans.
+ * Request-side capture for Bedrock spans: the prompt-caching config, and the
+ * AWS region the call was sent to.
  *
  * Bedrock callers opt into caching in the request body, in the model vendor's
  * own schema: Anthropic-on-Bedrock bodies carry `cache_control` blocks (the
@@ -12,11 +13,22 @@
  * request JSON) to stamp every breakpoint found as `weflayr.cache.breakpoints`.
  * Bedrock responses report no TTL split of the written tokens; the worker
  * derives it from these breakpoints when they all share one TTL.
+ *
+ * The region rides along: AWS bills a Bedrock call at the price of the region
+ * it is sent to, whatever geography a cross-region inference profile then
+ * routes it to, and a call carrying no region is priced by no row at all. Only
+ * the client names it, and `_startSpan` is handed the command but never the
+ * client, so `send` is wrapped to resolve the region and record it against the
+ * command the span is then started from. The client resolves its region
+ * through an async provider, hence the await before the call rather than a
+ * lookup inside `_startSpan`.
  */
 import { type CacheBreakpoint } from '../anthropic/get_cache_config_telemetry';
+export declare function recordCommandRegion(command: object, region: string): void;
 export declare function extractBedrockCacheBreakpoints(body: any): CacheBreakpoint[];
 export declare class BedrockCacheConfigInstrumentor {
     private _patched;
     instrument(instrumentation: any): void;
+    private _recordRegionPerCommand;
     uninstrument(): void;
 }

package/dist/src/instrumentation/bedrock/get_cache_config_telemetry.js

@@ -1,6 +1,7 @@
 "use strict";
 /**
- * Request-side prompt-caching config capture for Bedrock invoke_model spans.
+ * Request-side capture for Bedrock spans: the prompt-caching config, and the
+ * AWS region the call was sent to.
  *
  * Bedrock callers opt into caching in the request body, in the model vendor's
  * own schema: Anthropic-on-Bedrock bodies carry `cache_control` blocks (the
@@ -13,12 +14,32 @@
  * request JSON) to stamp every breakpoint found as `weflayr.cache.breakpoints`.
  * Bedrock responses report no TTL split of the written tokens; the worker
  * derives it from these breakpoints when they all share one TTL.
+ *
+ * The region rides along: AWS bills a Bedrock call at the price of the region
+ * it is sent to, whatever geography a cross-region inference profile then
+ * routes it to, and a call carrying no region is priced by no row at all. Only
+ * the client names it, and `_startSpan` is handed the command but never the
+ * client, so `send` is wrapped to resolve the region and record it against the
+ * command the span is then started from. The client resolves its region
+ * through an async provider, hence the await before the call rather than a
+ * lookup inside `_startSpan`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BedrockCacheConfigInstrumentor = void 0;
+exports.recordCommandRegion = recordCommandRegion;
 exports.extractBedrockCacheBreakpoints = extractBedrockCacheBreakpoints;
 const get_cache_config_telemetry_1 = require("../anthropic/get_cache_config_telemetry");
 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
+// command object, which `_startSpan` is called with synchronously, so an entry
+// is read by the span of its own call and by no other.
+const regionByCommand = new WeakMap();
+// Record the region a command was sent with. The `send` wrapper below is the
+// only production caller; the tests use it to stand in for a real client.
+function recordCommandRegion(command, region) {
+    regionByCommand.set(command, region);
+}
 // A breakpoint as location + the raw `cachePoint` `ttl` string, omitted when
 // the request sets none.
 function _cachePointEntry(location, cachePoint) {
@@ -79,6 +100,12 @@ class BedrockCacheConfigInstrumentor {
                         span.setAttribute(BREAKPOINTS_ATTR, JSON.stringify(breakpoints));
                     }
                 }
+                const command = request && request.params;
+                const region = command && regionByCommand.get(command);
+                if (region) {
+                    span.setAttribute(PROVIDER_REGION_ATTR, region);
+                    regionByCommand.delete(command);
+                }
             }
             catch {
                 // Never break span creation over an enrichment failure.
@@ -86,6 +113,34 @@ class BedrockCacheConfigInstrumentor {
             return span;
         };
         this._patched.push([instrumentation, '_startSpan', startSpanOriginal]);
+        this._recordRegionPerCommand();
+    }
+    // Wrap `send` outside the instrumentor's own wrapper, so the region is
+    // resolved and recorded before the span it belongs to is started.
+    _recordRegionPerCommand() {
+        let BedrockRuntimeClient;
+        try {
+            ({ BedrockRuntimeClient } = require('@aws-sdk/client-bedrock-runtime'));
+        }
+        catch {
+            // The caller reaches Bedrock another way: nothing to wrap.
+            return;
+        }
+        const sendOriginal = BedrockRuntimeClient.prototype.send;
+        if (typeof sendOriginal !== 'function')
+            return;
+        BedrockRuntimeClient.prototype.send = async function sendRecordingRegion(command, ...rest) {
+            try {
+                const region = await this.config.region();
+                if (region && command)
+                    recordCommandRegion(command, String(region));
+            }
+            catch {
+                // Never fail the call over an enrichment failure.
+            }
+            return sendOriginal.apply(this, [command, ...rest]);
+        };
+        this._patched.push([BedrockRuntimeClient.prototype, 'send', sendOriginal]);
     }
     uninstrument() {
         for (const [owner, methodName, original] of this._patched) {

package/dist/src/instrumentation/bedrock/get_cache_telemetry.js

@@ -65,7 +65,7 @@ class BedrockPromptCachingInstrumentor {
             instrumentation._wrapPromise = function wrapPromiseWithCache(span, promise, modelId) {
                 // Stamp cache tokens off the response, then hand the same response to the
                 // original handler (which decodes the still-buffered body for input/output
-                // tokens). Resolving to the original response keeps behaviour identical.
+                // tokens). Resolving to the original response keeps behavior identical.
                 const enriched = Promise.resolve(promise).then((response) => {
                     _setCacheTokens(span, response);
                     return response;
@@ -74,14 +74,17 @@ class BedrockPromptCachingInstrumentor {
             };
             this._patched.push([instrumentation, '_wrapPromise', wrapPromiseOriginal]);
         }
-        // Streamed: the instrumentor processes the trailing metadata chunk via
-        // `_handleNovaStreamingMetadata(span, parsedResponse)` (reading
-        // `parsedResponse.metadata.usage` for input/output) but never its cache counts.
+        // Streamed: the instrumentor hands every chunk to
+        // `_handleNovaStreamingMetadata(span, parsedResponse)` but never reads its
+        // cache counts: Nova's arrive in the trailing `metadata` chunk, Anthropic's
+        // in the opening `message_start` one.
         const metadataOriginal = instrumentation._handleNovaStreamingMetadata;
         if (typeof metadataOriginal === 'function') {
             instrumentation._handleNovaStreamingMetadata = function handleMetadataWithCache(span, parsedResponse) {
                 try {
-                    const usage = parsedResponse && parsedResponse.metadata && parsedResponse.metadata.usage;
+                    const usage = parsedResponse?.type === 'message_start'
+                        ? parsedResponse.message?.usage
+                        : parsedResponse?.metadata?.usage;
                     _setCacheFromUsage(span, usage);
                 }
                 catch {

package/dist/src/instrumentation/bedrock/get_model_id_telemetry.d.ts

@@ -6,7 +6,7 @@
  * "amazon.nova-micro-v1:0" becomes "nova-micro-v1:0" and
  * "us.anthropic.claude-haiku-4-5-20251001-v1:0" becomes
  * "claude-haiku-4-5-20251001-v1:0". Neither stripped form matches anything in the
- * pricing catalogue, whose Bedrock keys are the full ids, so those calls price at
+ * pricing catalog, whose Bedrock keys are the full ids, so those calls price at
  * nothing.
  *
  * Wrap `_startSpan({ params })` to re-stamp the id exactly as requested (so it

package/dist/src/instrumentation/bedrock/get_model_id_telemetry.js

@@ -7,7 +7,7 @@
  * "amazon.nova-micro-v1:0" becomes "nova-micro-v1:0" and
  * "us.anthropic.claude-haiku-4-5-20251001-v1:0" becomes
  * "claude-haiku-4-5-20251001-v1:0". Neither stripped form matches anything in the
- * pricing catalogue, whose Bedrock keys are the full ids, so those calls price at
+ * pricing catalog, whose Bedrock keys are the full ids, so those calls price at
  * nothing.
  *
  * Wrap `_startSpan({ params })` to re-stamp the id exactly as requested (so it

package/dist/src/instrumentation/bedrock/get_openai_chat_format_telemetry.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Telemetry for the Bedrock models whose InvokeModel body is OpenAI's chat
+ * completions format (Qwen, OpenAI's gpt-oss, DeepSeek, Kimi, MiniMax...).
+ *
+ * `@traceloop/instrumentation-bedrock` reads a request and its answer only for
+ * the vendors it knows (Amazon, Anthropic, Cohere, AI21, Meta), so a call to one
+ * of these models carries no request parameter and no answer, and is named a
+ * text completion. This complement:
+ *
+ * - names the call a chat (`_getOperationType`), and stamps its request
+ *   parameters once it succeeded (`_startSpan` keeps the request, which
+ *   `_endSpan`, only called on success, does not see), as the Python SDK
+ *   records them only off an answer;
+ * - stamps a non-streamed answer, its finish reason, token counts, response
+ *   model and id (`_setResponseAttributes`);
+ * - accumulates a stream into the body a non-streamed call answers, chunk by
+ *   chunk (`_handleNovaStreamingMetadata`, which the instrumentor calls for
+ *   every chunk whatever the vendor), and stamps it from the closing chunk.
+ *   The instrumentor stamps a stream's token counts itself, off the closing
+ *   chunk's `amazon-bedrock-invocationMetrics`.
+ *
+ * The input messages and the tool definitions are stamped by their own
+ * complements, which read a `messages` body whatever its vendor.
+ */
+export declare function isOpenaiChatFormat(modelVendor: string, requestBody: any): boolean;
+/**
+ * Fold one streamed chunk into the body a non-streamed call answers: the text
+ * deltas and each tool call's argument fragments are joined, and the token
+ * counts come from the closing chunk's invocation metrics.
+ *
+ * Example: chunks with deltas {content: "Hel"} then {content: "lo"}, then
+ * finish_reason "stop" and invocation metrics {inputTokenCount: 18,
+ * outputTokenCount: 4} give {choices: [{message: {content: "Hello",
+ * tool_calls: []}, finish_reason: "stop"}], usage: {prompt_tokens: 18,
+ * completion_tokens: 4}, ...}.
+ */
+export declare function accumulateStreamChunk(accumulatingBody: any, chunk: any): void;
+export declare function setRequestAndUsageAttributes(span: any, requestBody: any, responseBody: any): void;
+/** The finish reasons, and the answer when its content is captured. */
+export declare function setOutputAttributes(span: any, responseBody: any, shouldSendPrompts: boolean): void;
+export declare class BedrockOpenaiChatFormatInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

package/dist/src/instrumentation/bedrock/get_openai_chat_format_telemetry.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * Telemetry for the Bedrock models whose InvokeModel body is OpenAI's chat
+ * completions format (Qwen, OpenAI's gpt-oss, DeepSeek, Kimi, MiniMax...).
+ *
+ * `@traceloop/instrumentation-bedrock` reads a request and its answer only for
+ * the vendors it knows (Amazon, Anthropic, Cohere, AI21, Meta), so a call to one
+ * of these models carries no request parameter and no answer, and is named a
+ * text completion. This complement:
+ *
+ * - names the call a chat (`_getOperationType`), and stamps its request
+ *   parameters once it succeeded (`_startSpan` keeps the request, which
+ *   `_endSpan`, only called on success, does not see), as the Python SDK
+ *   records them only off an answer;
+ * - stamps a non-streamed answer, its finish reason, token counts, response
+ *   model and id (`_setResponseAttributes`);
+ * - accumulates a stream into the body a non-streamed call answers, chunk by
+ *   chunk (`_handleNovaStreamingMetadata`, which the instrumentor calls for
+ *   every chunk whatever the vendor), and stamps it from the closing chunk.
+ *   The instrumentor stamps a stream's token counts itself, off the closing
+ *   chunk's `amazon-bedrock-invocationMetrics`.
+ *
+ * The input messages and the tool definitions are stamped by their own
+ * complements, which read a `messages` body whatever its vendor.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockOpenaiChatFormatInstrumentor = void 0;
+exports.isOpenaiChatFormat = isOpenaiChatFormat;
+exports.accumulateStreamChunk = accumulateStreamChunk;
+exports.setRequestAndUsageAttributes = setRequestAndUsageAttributes;
+exports.setOutputAttributes = setOutputAttributes;
+// The vendors the instrumentor reads itself; every other vendor's body is
+// OpenAI's chat completions format.
+const VENDORS_READ_BY_THE_INSTRUMENTOR = new Set(['cohere', 'anthropic', 'ai21', 'meta', 'amazon']);
+const INVOCATION_METRICS_KEY = 'amazon-bedrock-invocationMetrics';
+// OpenAI's finish reasons, in the OpenTelemetry GenAI vocabulary the other
+// vendors' answers are recorded in.
+const FINISH_REASON_BY_OPENAI_FINISH_REASON = {
+    stop: 'stop',
+    length: 'length',
+    tool_calls: 'tool_call',
+    content_filter: 'content_filter',
+};
+function isOpenaiChatFormat(modelVendor, requestBody) {
+    return (!VENDORS_READ_BY_THE_INSTRUMENTOR.has(modelVendor) &&
+        requestBody !== null &&
+        typeof requestBody === 'object' &&
+        Array.isArray(requestBody.messages));
+}
+/**
+ * Fold one streamed chunk into the body a non-streamed call answers: the text
+ * deltas and each tool call's argument fragments are joined, and the token
+ * counts come from the closing chunk's invocation metrics.
+ *
+ * Example: chunks with deltas {content: "Hel"} then {content: "lo"}, then
+ * finish_reason "stop" and invocation metrics {inputTokenCount: 18,
+ * outputTokenCount: 4} give {choices: [{message: {content: "Hello",
+ * tool_calls: []}, finish_reason: "stop"}], usage: {prompt_tokens: 18,
+ * completion_tokens: 4}, ...}.
+ */
+function accumulateStreamChunk(accumulatingBody, chunk) {
+    accumulatingBody.id ??= chunk.id;
+    accumulatingBody.model ??= chunk.model;
+    accumulatingBody.choices ??= [{ message: { content: '', tool_calls: [] } }];
+    const choices = accumulatingBody.choices;
+    const message = choices[0].message;
+    for (const choice of chunk.choices || []) {
+        const delta = choice.delta || {};
+        message.content += delta.content || '';
+        for (const toolCallDelta of delta.tool_calls || []) {
+            const index = toolCallDelta.index ?? 0;
+            while (message.tool_calls.length <= index) {
+                message.tool_calls.push({ id: null, function: { name: '', arguments: '' } });
+            }
+            const toolCall = message.tool_calls[index];
+            toolCall.id = toolCallDelta.id || toolCall.id;
+            const functionDelta = toolCallDelta.function || {};
+            toolCall.function.name += functionDelta.name || '';
+            toolCall.function.arguments += functionDelta.arguments || '';
+        }
+        if (choice.finish_reason)
+            choices[0].finish_reason = choice.finish_reason;
+    }
+    const invocationMetrics = chunk[INVOCATION_METRICS_KEY];
+    if (invocationMetrics && typeof invocationMetrics === 'object') {
+        accumulatingBody.usage = {
+            prompt_tokens: invocationMetrics.inputTokenCount,
+            completion_tokens: invocationMetrics.outputTokenCount,
+        };
+    }
+}
+function setRequestAndUsageAttributes(span, requestBody, responseBody) {
+    const attributes = {
+        'gen_ai.request.max_tokens': requestBody.max_tokens ?? requestBody.max_completion_tokens,
+        'gen_ai.request.temperature': requestBody.temperature,
+        'gen_ai.request.top_p': requestBody.top_p,
+        'gen_ai.response.model': responseBody.model,
+        'gen_ai.response.id': responseBody.id,
+    };
+    const usage = responseBody.usage || {};
+    const inputTokens = usage.prompt_tokens;
+    const outputTokens = usage.completion_tokens;
+    if (Number.isInteger(inputTokens) && Number.isInteger(outputTokens)) {
+        attributes['gen_ai.usage.input_tokens'] = inputTokens;
+        attributes['gen_ai.usage.output_tokens'] = outputTokens;
+        attributes['gen_ai.usage.total_tokens'] = inputTokens + outputTokens;
+    }
+    for (const [name, value] of Object.entries(attributes)) {
+        if (value !== undefined && value !== null)
+            span.setAttribute(name, value);
+    }
+}
+function _parseArguments(argumentsJson) {
+    try {
+        return JSON.parse(argumentsJson);
+    }
+    catch {
+        return argumentsJson;
+    }
+}
+function _getFinishReason(choice) {
+    const openaiFinishReason = choice.finish_reason || '';
+    return FINISH_REASON_BY_OPENAI_FINISH_REASON[openaiFinishReason] ?? openaiFinishReason;
+}
+/** The finish reasons, and the answer when its content is captured. */
+function setOutputAttributes(span, responseBody, shouldSendPrompts) {
+    const choices = responseBody.choices || [];
+    const finishReasons = choices.filter((choice) => choice.finish_reason).map(_getFinishReason);
+    if (finishReasons.length)
+        span.setAttribute('gen_ai.response.finish_reasons', finishReasons);
+    if (!shouldSendPrompts)
+        return;
+    const outputMessages = choices.map((choice) => {
+        const message = choice.message || {};
+        const parts = [];
+        if (message.content)
+            parts.push({ type: 'text', content: message.content });
+        for (const toolCall of message.tool_calls || []) {
+            parts.push({
+                type: 'tool_call',
+                id: toolCall.id,
+                name: toolCall.function?.name,
+                arguments: _parseArguments(toolCall.function?.arguments || ''),
+            });
+        }
+        return { role: 'assistant', parts, finish_reason: _getFinishReason(choice) };
+    });
+    span.setAttribute('gen_ai.output.messages', JSON.stringify(outputMessages));
+}
+class BedrockOpenaiChatFormatInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals have changed shape:
+    // the worst case is a call recorded without its answer, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const originalGetOperationType = instrumentation._getOperationType;
+        const originalStartSpan = instrumentation._startSpan;
+        const originalSetResponseAttributes = instrumentation._setResponseAttributes;
+        const originalHandleStreamChunk = instrumentation._handleNovaStreamingMetadata;
+        const originalEndSpan = instrumentation._endSpan;
+        if (typeof originalGetOperationType !== 'function' ||
+            typeof originalStartSpan !== 'function' ||
+            typeof originalSetResponseAttributes !== 'function' ||
+            typeof originalHandleStreamChunk !== 'function' ||
+            typeof originalEndSpan !== 'function') {
+            return;
+        }
+        // span -> the request and the answer accumulated so far, for an
+        // OpenAI-format call.
+        const callBySpan = new WeakMap();
+        instrumentation._getOperationType = function getOperationType(vendor, requestBody) {
+            if (isOpenaiChatFormat(vendor, requestBody))
+                return 'chat';
+            return originalGetOperationType.call(this, vendor, requestBody);
+        };
+        instrumentation._startSpan = function startSpanRecordingOpenaiChatFormatCalls(request) {
+            const span = originalStartSpan.call(this, request);
+            try {
+                const input = request?.params?.input;
+                const requestBody = typeof input?.body === 'string' ? JSON.parse(input.body) : null;
+                const { modelVendor } = this._extractVendorAndModel(input?.modelId || '');
+                if (isOpenaiChatFormat(modelVendor, requestBody)) {
+                    callBySpan.set(span, { requestBody, accumulatingBody: {} });
+                }
+            }
+            catch {
+                // Never break span creation over an enrichment failure.
+            }
+            return span;
+        };
+        instrumentation._setResponseAttributes = function setResponseAttributesOfOpenaiChatFormat(vendor, response, isStream = false, ...args) {
+            const attributes = originalSetResponseAttributes.call(this, vendor, response, isStream, ...args);
+            try {
+                if (!isStream &&
+                    !VENDORS_READ_BY_THE_INSTRUMENTOR.has(vendor) &&
+                    Array.isArray(response?.choices)) {
+                    const recordedAttributes = {};
+                    const attributeCollector = {
+                        setAttribute(name, value) {
+                            recordedAttributes[name] = value;
+                        },
+                    };
+                    setRequestAndUsageAttributes(attributeCollector, {}, response);
+                    setOutputAttributes(attributeCollector, response, this._shouldSendPrompts());
+                    return { ...attributes, ...recordedAttributes };
+                }
+            }
+            catch {
+                // Never break the response handling over an enrichment failure.
+            }
+            return attributes;
+        };
+        instrumentation._handleNovaStreamingMetadata = function handleOpenaiChatFormatStreamChunk(span, parsedResponse) {
+            try {
+                const call = callBySpan.get(span);
+                if (call) {
+                    accumulateStreamChunk(call.accumulatingBody, parsedResponse);
+                    if (parsedResponse && INVOCATION_METRICS_KEY in parsedResponse) {
+                        setRequestAndUsageAttributes(span, {}, call.accumulatingBody);
+                        setOutputAttributes(span, call.accumulatingBody, this._shouldSendPrompts());
+                    }
+                }
+            }
+            catch {
+                // Never break the caller's stream over an enrichment failure.
+            }
+            return originalHandleStreamChunk.call(this, span, parsedResponse);
+        };
+        instrumentation._endSpan = function endSpanWithOpenaiChatFormatRequest(endSpanArguments) {
+            try {
+                const call = callBySpan.get(endSpanArguments?.span);
+                if (call)
+                    setRequestAndUsageAttributes(endSpanArguments.span, call.requestBody, {});
+            }
+            catch {
+                // Never break the response handling over an enrichment failure.
+            }
+            return originalEndSpan.call(this, endSpanArguments);
+        };
+        this._patched.push([instrumentation, '_getOperationType', originalGetOperationType], [instrumentation, '_startSpan', originalStartSpan], [instrumentation, '_setResponseAttributes', originalSetResponseAttributes], [instrumentation, '_handleNovaStreamingMetadata', originalHandleStreamChunk], [instrumentation, '_endSpan', originalEndSpan]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of [...this._patched].reverse()) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.BedrockOpenaiChatFormatInstrumentor = BedrockOpenaiChatFormatInstrumentor;

package/dist/src/instrumentation/bedrock/get_streaming_output_message_telemetry.d.ts

@@ -6,11 +6,12 @@
  * 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.
+ * hook: it accumulates the text and the stop reason itself, Nova's
+ * (`contentBlockDelta`, `messageStop`) and Anthropic's (`content_block_delta`,
+ * `message_delta`), and re-stamps a correct output message when the stream's
+ * last chunk arrives (Nova's trailing `metadata`, Anthropic's `message_stop`),
+ * after the instrumentor has written its empty-parts message. The span
+ * processor strips the attribute when message-content capture is disabled.
  *
  * A streamed tool call is accumulated the same way and for the same reason:
  * `contentBlockStart` opens it with an id and name, `contentBlockDelta` appends

package/dist/src/instrumentation/bedrock/get_streaming_output_message_telemetry.js

@@ -7,11 +7,12 @@
  * 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.
+ * hook: it accumulates the text and the stop reason itself, Nova's
+ * (`contentBlockDelta`, `messageStop`) and Anthropic's (`content_block_delta`,
+ * `message_delta`), and re-stamps a correct output message when the stream's
+ * last chunk arrives (Nova's trailing `metadata`, Anthropic's `message_stop`),
+ * after the instrumentor has written its empty-parts message. The span
+ * processor strips the attribute when message-content capture is disabled.
  *
  * A streamed tool call is accumulated the same way and for the same reason:
  * `contentBlockStart` opens it with an id and name, `contentBlockDelta` appends
@@ -22,7 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BedrockStreamingOutputMessageInstrumentor = void 0;
-// Nova stop reasons mapped to the OTel finish_reason values the instrumentor
+// Nova's and Anthropic's 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',
@@ -75,18 +76,20 @@ class BedrockStreamingOutputMessageInstrumentor {
                     stopReason: null,
                     toolCalls: [],
                 };
-                const delta = parsedResponse &&
-                    parsedResponse.contentBlockDelta &&
-                    parsedResponse.contentBlockDelta.delta &&
-                    parsedResponse.contentBlockDelta.delta.text;
+                const delta = parsedResponse?.contentBlockDelta?.delta?.text ??
+                    (parsedResponse?.type === 'content_block_delta' ? parsedResponse.delta?.text : undefined);
                 if (typeof delta === 'string')
                     state.text += delta;
-                const stopReason = parsedResponse && parsedResponse.messageStop && parsedResponse.messageStop.stopReason;
+                const stopReason = parsedResponse?.messageStop?.stopReason ??
+                    (parsedResponse?.type === 'message_delta'
+                        ? parsedResponse.delta?.stop_reason
+                        : undefined);
                 if (stopReason != null)
                     state.stopReason = stopReason;
                 _accumulateToolCall(state, parsedResponse);
                 streamStateBySpan.set(span, state);
-                if (parsedResponse && parsedResponse.metadata && (state.text || state.toolCalls.length)) {
+                const isLastChunk = parsedResponse?.metadata || parsedResponse?.type === 'message_stop';
+                if (isLastChunk && (state.text || state.toolCalls.length)) {
                     const parts = [];
                     if (state.text)
                         parts.push({ type: 'text', content: state.text });

package/dist/src/instrumentation/bedrock/get_tool_definitions_telemetry.d.ts

@@ -5,8 +5,8 @@
  * the inference config but never for its `toolConfig`, so a tool-using call
  * carries no `gen_ai.tool.definitions`. Wrap the instrumentor's
  * `_startSpan({ params })` to stamp the definitions from the request body,
- * unwrapping each entry's `toolSpec` so the attribute holds the bare
- * `{name, description, inputSchema}` definitions rather than Bedrock's wrapper.
+ * unwrapping each entry's `toolSpec` (or OpenAI's `function`) so the attribute
+ * holds the bare definitions rather than their wrapper.
  */
 export declare class BedrockToolDefinitionsInstrumentor {
     private _patched;

package/dist/src/instrumentation/bedrock/get_tool_definitions_telemetry.js

@@ -6,14 +6,17 @@
  * the inference config but never for its `toolConfig`, so a tool-using call
  * carries no `gen_ai.tool.definitions`. Wrap the instrumentor's
  * `_startSpan({ params })` to stamp the definitions from the request body,
- * unwrapping each entry's `toolSpec` so the attribute holds the bare
- * `{name, description, inputSchema}` definitions rather than Bedrock's wrapper.
+ * unwrapping each entry's `toolSpec` (or OpenAI's `function`) so the attribute
+ * holds the bare definitions rather than their wrapper.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BedrockToolDefinitionsInstrumentor = void 0;
-// The bare tool definitions from an InvokeModel JSON body, e.g.
+// The bare tool definitions from an InvokeModel JSON body: Nova's, e.g.
 // `{"toolConfig": {"tools": [{"toolSpec": {"name": "get_weather", ...}}]}}`
-// -> `[{"name": "get_weather", ...}]`.
+// -> `[{"name": "get_weather", ...}]`, or OpenAI's chat completions format, e.g.
+// `{"tools": [{"type": "function", "function": {"name": "get_weather", ...}}]}`
+// -> `[{"name": "get_weather", ...}]`. An Anthropic body's tools, which the
+// instrumentor records itself, give none.
 function _toolDefinitionsFromRequestBody(rawBody) {
     if (typeof rawBody !== 'string')
         return [];
@@ -24,6 +27,11 @@ function _toolDefinitionsFromRequestBody(rawBody) {
     catch {
         return [];
     }
+    if (body && Array.isArray(body.tools)) {
+        return body.tools
+            .filter((tool) => tool && typeof tool.function === 'object' && tool.function !== null)
+            .map((tool) => tool.function);
+    }
     const tools = body && body.toolConfig && body.toolConfig.tools;
     if (!Array.isArray(tools))
         return [];

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

@@ -7,8 +7,10 @@
  * breakpoints (`cache_control` / `cachePoint` blocks it never records), the
  * streamed output message content (its stream path formats an empty-parts
  * message), the request's tool definitions (it never reads the body's
- * `toolConfig`) and the tool-call output parts (its block mapper only knows
- * Anthropic's block shape, so Nova's `toolUse` blocks come through raw).
+ * `toolConfig`), the tool-call output parts (its block mapper only knows
+ * Anthropic's block shape, so Nova's `toolUse` blocks come through raw), and
+ * everything about a model whose body is OpenAI's chat completions format (it
+ * reads only the vendors it knows).
  */
 export declare class BedrockTelemetryInstrumentor {
     private _subInstrumentors;

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

@@ -8,8 +8,10 @@
  * breakpoints (`cache_control` / `cachePoint` blocks it never records), the
  * streamed output message content (its stream path formats an empty-parts
  * message), the request's tool definitions (it never reads the body's
- * `toolConfig`) and the tool-call output parts (its block mapper only knows
- * Anthropic's block shape, so Nova's `toolUse` blocks come through raw).
+ * `toolConfig`), the tool-call output parts (its block mapper only knows
+ * Anthropic's block shape, so Nova's `toolUse` blocks come through raw), and
+ * everything about a model whose body is OpenAI's chat completions format (it
+ * reads only the vendors it knows).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BedrockTelemetryInstrumentor = void 0;
@@ -18,6 +20,7 @@ const get_cache_telemetry_1 = require("./get_cache_telemetry");
 const get_input_message_content_telemetry_1 = require("./get_input_message_content_telemetry");
 const get_streaming_output_message_telemetry_1 = require("./get_streaming_output_message_telemetry");
 const get_model_id_telemetry_1 = require("./get_model_id_telemetry");
+const get_openai_chat_format_telemetry_1 = require("./get_openai_chat_format_telemetry");
 const get_reasoning_output_telemetry_1 = require("./get_reasoning_output_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");
@@ -33,14 +36,18 @@ class BedrockTelemetryInstrumentor {
             new get_tool_call_output_telemetry_1.BedrockToolCallOutputInstrumentor(),
             new get_model_id_telemetry_1.BedrockModelIdInstrumentor(),
             new get_reasoning_output_telemetry_1.BedrockReasoningOutputInstrumentor(),
+            new get_openai_chat_format_telemetry_1.BedrockOpenaiChatFormatInstrumentor(),
         ];
     }
     instrument(instrumentation) {
         for (const sub of this._subInstrumentors)
             sub.instrument(instrumentation);
     }
+    // Reversed: several complements wrap the same instrumentor method
+    // (`_startSpan`), so the patches have to be unwound last-patched-first or an
+    // earlier wrapper is written back over a later one and stays installed.
     uninstrument() {
-        for (const sub of this._subInstrumentors)
+        for (const sub of [...this._subInstrumentors].reverse())
             sub.uninstrument();
     }
 }