weflayr 0.24.0 → 0.26.1

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

@@ -0,0 +1,21 @@
+/**
+ * The full Bedrock model id on invoke_model spans.
+ *
+ * `@traceloop/instrumentation-bedrock` splits the vendor segment off the
+ * requested `modelId` before stamping `gen_ai.request.model`:
+ * "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
+ * nothing.
+ *
+ * Wrap `_startSpan({ params })` to re-stamp the id exactly as requested (so it
+ * lands on error spans too). The Python SDK does the same from botocore's
+ * `_make_api_call`, and the normalizer prefers the request model over the
+ * response one for Bedrock-SDK spans.
+ */
+export declare class BedrockModelIdInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * The full Bedrock model id on invoke_model spans.
+ *
+ * `@traceloop/instrumentation-bedrock` splits the vendor segment off the
+ * requested `modelId` before stamping `gen_ai.request.model`:
+ * "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
+ * nothing.
+ *
+ * Wrap `_startSpan({ params })` to re-stamp the id exactly as requested (so it
+ * lands on error spans too). The Python SDK does the same from botocore's
+ * `_make_api_call`, and the normalizer prefers the request model over the
+ * response one for Bedrock-SDK spans.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockModelIdInstrumentor = void 0;
+const REQUEST_MODEL_ATTR = 'gen_ai.request.model';
+class BedrockModelIdInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals have changed shape —
+    // the worst case is the stripped model id, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const original = instrumentation._startSpan;
+        if (typeof original !== 'function')
+            return;
+        instrumentation._startSpan = function startSpanWithFullModelId(request) {
+            const span = original.call(this, request);
+            try {
+                const modelId = request?.params?.input?.modelId;
+                if (span && typeof modelId === 'string' && modelId) {
+                    span.setAttribute(REQUEST_MODEL_ATTR, modelId);
+                }
+            }
+            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 = [];
+    }
+}
+exports.BedrockModelIdInstrumentor = BedrockModelIdInstrumentor;

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

@@ -0,0 +1,19 @@
+/**
+ * Reasoning output parts for Claude-on-Bedrock invoke_model spans.
+ *
+ * `@traceloop/instrumentation-bedrock` maps each response content block through a
+ * mapper that does not know Anthropic's extended-thinking block, so a
+ * `{type: "thinking", thinking, signature}` block falls through unchanged and
+ * `gen_ai.output.messages` ends up holding Bedrock's raw block. Wrap
+ * `_setResponseAttributes` to rewrite those parts into the OTel
+ * `{type: "reasoning", content}` shape the Python SDK already emits, so both SDKs
+ * normalize a chain of thought identically.
+ *
+ * The block's `signature` (Anthropic's attestation of the thinking text) is
+ * dropped: it is not content, and the Python instrumentor does not emit it.
+ */
+export declare class BedrockReasoningOutputInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Reasoning output parts for Claude-on-Bedrock invoke_model spans.
+ *
+ * `@traceloop/instrumentation-bedrock` maps each response content block through a
+ * mapper that does not know Anthropic's extended-thinking block, so a
+ * `{type: "thinking", thinking, signature}` block falls through unchanged and
+ * `gen_ai.output.messages` ends up holding Bedrock's raw block. Wrap
+ * `_setResponseAttributes` to rewrite those parts into the OTel
+ * `{type: "reasoning", content}` shape the Python SDK already emits, so both SDKs
+ * normalize a chain of thought identically.
+ *
+ * The block's `signature` (Anthropic's attestation of the thinking text) is
+ * dropped: it is not content, and the Python instrumentor does not emit it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockReasoningOutputInstrumentor = void 0;
+function _mapThinkingPart(part) {
+    if (!part || part.type !== 'thinking' || typeof part.thinking !== 'string')
+        return part;
+    return { type: 'reasoning', content: part.thinking };
+}
+function _rewriteReasoningParts(rawOutputMessages) {
+    if (typeof rawOutputMessages !== 'string')
+        return null;
+    let messages;
+    try {
+        messages = JSON.parse(rawOutputMessages);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(messages))
+        return null;
+    let rewroteAny = false;
+    const rewritten = messages.map((message) => {
+        if (!message || !Array.isArray(message.parts))
+            return message;
+        const parts = message.parts.map((part) => {
+            const mapped = _mapThinkingPart(part);
+            if (mapped !== part)
+                rewroteAny = true;
+            return mapped;
+        });
+        return { ...message, parts };
+    });
+    return rewroteAny ? JSON.stringify(rewritten) : null;
+}
+class BedrockReasoningOutputInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals have changed shape —
+    // the worst case is the raw upstream part shape, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const original = instrumentation._setResponseAttributes;
+        if (typeof original !== 'function')
+            return;
+        instrumentation._setResponseAttributes = function setResponseAttributesWithReasoning(...args) {
+            const attributes = original.apply(this, args);
+            try {
+                const rewritten = _rewriteReasoningParts(attributes['gen_ai.output.messages']);
+                if (rewritten !== null)
+                    attributes['gen_ai.output.messages'] = rewritten;
+            }
+            catch {
+                // Never break the response handling over an enrichment failure.
+            }
+            return attributes;
+        };
+        this._patched.push([instrumentation, '_setResponseAttributes', original]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.BedrockReasoningOutputInstrumentor = BedrockReasoningOutputInstrumentor;

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

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ *
+ * A streamed tool call is accumulated the same way and for the same reason:
+ * `contentBlockStart` opens it with an id and name, `contentBlockDelta` appends
+ * its JSON arguments in fragments, and upstream reads neither — so without this
+ * a forced tool call streams into an empty message carrying only
+ * `finish_reason: "tool_call"`. Upstream accumulates tool blocks on the Converse
+ * API path only, never on InvokeModelWithResponseStream.
+ */
+export declare class BedrockStreamingOutputMessageInstrumentor {
+    private _patched;
+    private _streamStateBySpan;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,126 @@
+"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.
+ *
+ * A streamed tool call is accumulated the same way and for the same reason:
+ * `contentBlockStart` opens it with an id and name, `contentBlockDelta` appends
+ * its JSON arguments in fragments, and upstream reads neither — so without this
+ * a forced tool call streams into an empty message carrying only
+ * `finish_reason: "tool_call"`. Upstream accumulates tool blocks on the Converse
+ * API path only, never on InvokeModelWithResponseStream.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockStreamingOutputMessageInstrumentor = void 0;
+// 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',
+};
+function _parseArguments(argumentsJson) {
+    try {
+        return JSON.parse(argumentsJson);
+    }
+    catch {
+        return argumentsJson;
+    }
+}
+/** Gather a streamed tool call across the chunks that carry it. */
+function _accumulateToolCall(state, parsedResponse) {
+    const startToolUse = parsedResponse?.contentBlockStart?.start?.toolUse;
+    if (startToolUse) {
+        state.toolCalls.push({
+            id: startToolUse.toolUseId,
+            name: startToolUse.name,
+            arguments: '',
+        });
+        return;
+    }
+    const deltaToolUse = parsedResponse?.contentBlockDelta?.delta?.toolUse;
+    if (deltaToolUse && state.toolCalls.length) {
+        state.toolCalls[state.toolCalls.length - 1].arguments += deltaToolUse.input ?? '';
+    }
+}
+class BedrockStreamingOutputMessageInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // span -> {text, stopReason} accumulated across the stream's chunks.
+    _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,
+                    toolCalls: [],
+                };
+                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;
+                _accumulateToolCall(state, parsedResponse);
+                streamStateBySpan.set(span, state);
+                if (parsedResponse && parsedResponse.metadata && (state.text || state.toolCalls.length)) {
+                    const parts = [];
+                    if (state.text)
+                        parts.push({ type: 'text', content: state.text });
+                    for (const toolCall of state.toolCalls) {
+                        parts.push({
+                            type: 'tool_call',
+                            id: toolCall.id,
+                            name: toolCall.name,
+                            arguments: _parseArguments(toolCall.arguments),
+                        });
+                    }
+                    const message = {
+                        role: 'assistant',
+                        parts,
+                    };
+                    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 = [];
+    }
+}
+exports.BedrockStreamingOutputMessageInstrumentor = BedrockStreamingOutputMessageInstrumentor;

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

@@ -0,0 +1,17 @@
+/**
+ * Tool-call output parts for Bedrock invoke_model spans.
+ *
+ * `@traceloop/instrumentation-bedrock` maps each response content block through
+ * a mapper keyed on Anthropic's block vocabulary (`{type: "tool_use"}`). Nova's
+ * InvokeModel response instead returns `{toolUse: {name, toolUseId, input}}`
+ * blocks, which carry no `type`, so they fall through the mapper unchanged and
+ * `gen_ai.output.messages` ends up holding Bedrock's raw block. Wrap
+ * `_setResponseAttributes` to rewrite those parts into the OTel
+ * `{type: "tool_call", id, name, arguments}` shape the Python SDK already
+ * emits, so both SDKs normalize a tool call identically.
+ */
+export declare class BedrockToolCallOutputInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Tool-call output parts for Bedrock invoke_model spans.
+ *
+ * `@traceloop/instrumentation-bedrock` maps each response content block through
+ * a mapper keyed on Anthropic's block vocabulary (`{type: "tool_use"}`). Nova's
+ * InvokeModel response instead returns `{toolUse: {name, toolUseId, input}}`
+ * blocks, which carry no `type`, so they fall through the mapper unchanged and
+ * `gen_ai.output.messages` ends up holding Bedrock's raw block. Wrap
+ * `_setResponseAttributes` to rewrite those parts into the OTel
+ * `{type: "tool_call", id, name, arguments}` shape the Python SDK already
+ * emits, so both SDKs normalize a tool call identically.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockToolCallOutputInstrumentor = void 0;
+function _mapToolUsePart(part) {
+    const toolUse = part && part.toolUse;
+    if (!toolUse || typeof toolUse !== 'object')
+        return part;
+    return {
+        type: 'tool_call',
+        id: toolUse.toolUseId,
+        name: toolUse.name,
+        arguments: toolUse.input,
+    };
+}
+function _rewriteToolCallParts(rawOutputMessages) {
+    if (typeof rawOutputMessages !== 'string')
+        return null;
+    let messages;
+    try {
+        messages = JSON.parse(rawOutputMessages);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(messages))
+        return null;
+    let rewroteAny = false;
+    const rewritten = messages.map((message) => {
+        if (!message || !Array.isArray(message.parts))
+            return message;
+        const parts = message.parts.map((part) => {
+            const mapped = _mapToolUsePart(part);
+            if (mapped !== part)
+                rewroteAny = true;
+            return mapped;
+        });
+        return { ...message, parts };
+    });
+    return rewroteAny ? JSON.stringify(rewritten) : null;
+}
+class BedrockToolCallOutputInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals have changed shape —
+    // the worst case is the raw upstream part shape, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const original = instrumentation._setResponseAttributes;
+        if (typeof original !== 'function')
+            return;
+        instrumentation._setResponseAttributes = function setResponseAttributesWithToolCalls(...args) {
+            const attributes = original.apply(this, args);
+            try {
+                const rewritten = _rewriteToolCallParts(attributes['gen_ai.output.messages']);
+                if (rewritten !== null)
+                    attributes['gen_ai.output.messages'] = rewritten;
+            }
+            catch {
+                // Never break the response handling over an enrichment failure.
+            }
+            return attributes;
+        };
+        this._patched.push([instrumentation, '_setResponseAttributes', original]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.BedrockToolCallOutputInstrumentor = BedrockToolCallOutputInstrumentor;

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

@@ -0,0 +1,15 @@
+/**
+ * Tool definitions for Bedrock invoke_model spans.
+ *
+ * `@traceloop/instrumentation-bedrock` reads the request body for the prompt and
+ * 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.
+ */
+export declare class BedrockToolDefinitionsInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Tool definitions for Bedrock invoke_model spans.
+ *
+ * `@traceloop/instrumentation-bedrock` reads the request body for the prompt and
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockToolDefinitionsInstrumentor = void 0;
+// The bare tool definitions from an InvokeModel JSON body, e.g.
+// `{"toolConfig": {"tools": [{"toolSpec": {"name": "get_weather", ...}}]}}`
+// -> `[{"name": "get_weather", ...}]`.
+function _toolDefinitionsFromRequestBody(rawBody) {
+    if (typeof rawBody !== 'string')
+        return [];
+    let body;
+    try {
+        body = JSON.parse(rawBody);
+    }
+    catch {
+        return [];
+    }
+    const tools = body && body.toolConfig && body.toolConfig.tools;
+    if (!Array.isArray(tools))
+        return [];
+    return tools
+        .filter((tool) => tool && typeof tool.toolSpec === 'object' && tool.toolSpec !== null)
+        .map((tool) => tool.toolSpec);
+}
+class BedrockToolDefinitionsInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _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 original = instrumentation._startSpan;
+        if (typeof original !== 'function')
+            return;
+        instrumentation._startSpan = function startSpanWithToolDefinitions(request) {
+            const span = original.call(this, request);
+            try {
+                const body = request && request.params && request.params.input && request.params.input.body;
+                const definitions = _toolDefinitionsFromRequestBody(body);
+                if (definitions.length) {
+                    span.setAttribute('gen_ai.tool.definitions', JSON.stringify(definitions));
+                }
+            }
+            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 = [];
+    }
+}
+exports.BedrockToolDefinitionsInstrumentor = BedrockToolDefinitionsInstrumentor;

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

@@ -0,0 +1,18 @@
+/**
+ * Bedrock telemetry complement — the registered orchestrator.
+ *
+ * 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), the request's cache
+ * 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).
+ */
+export declare class BedrockTelemetryInstrumentor {
+    private _subInstrumentors;
+    constructor();
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Bedrock telemetry complement — the registered orchestrator.
+ *
+ * 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), the request's cache
+ * 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).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockTelemetryInstrumentor = void 0;
+const get_cache_config_telemetry_1 = require("./get_cache_config_telemetry");
+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_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");
+class BedrockTelemetryInstrumentor {
+    _subInstrumentors;
+    constructor() {
+        this._subInstrumentors = [
+            new get_cache_telemetry_1.BedrockPromptCachingInstrumentor(),
+            new get_cache_config_telemetry_1.BedrockCacheConfigInstrumentor(),
+            new get_input_message_content_telemetry_1.BedrockInputMessageContentInstrumentor(),
+            new get_streaming_output_message_telemetry_1.BedrockStreamingOutputMessageInstrumentor(),
+            new get_tool_definitions_telemetry_1.BedrockToolDefinitionsInstrumentor(),
+            new get_tool_call_output_telemetry_1.BedrockToolCallOutputInstrumentor(),
+            new get_model_id_telemetry_1.BedrockModelIdInstrumentor(),
+            new get_reasoning_output_telemetry_1.BedrockReasoningOutputInstrumentor(),
+        ];
+    }
+    instrument(instrumentation) {
+        for (const sub of this._subInstrumentors)
+            sub.instrument(instrumentation);
+    }
+    uninstrument() {
+        for (const sub of this._subInstrumentors)
+            sub.uninstrument();
+    }
+}
+exports.BedrockTelemetryInstrumentor = BedrockTelemetryInstrumentor;

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

@@ -0,0 +1,23 @@
+/**
+ * Chat token-usage enrichment complement for the Cohere v1 chat path.
+ *
+ * `@traceloop/instrumentation-cohere` creates the `cohere.chat` span but reads
+ * token usage from the obsolete `result.token_count.{prompt,response}_tokens`
+ * shape; modern cohere-ai returns usage under `meta.billedUnits` instead, so the
+ * traceloop span ends up with zero chat tokens. This thin complement backfills
+ * `gen_ai.usage.{input,output}_tokens` from `meta.billedUnits`, the same source
+ * traceloop already uses for the `generate` endpoint — bringing Node chat tokens
+ * to parity with the Python SDK (OpenLLMetry captures them natively, so there is
+ * no Python counterpart).
+ *
+ * It hooks the internal `CohereClient.prototype.__chat` (which the public `chat`
+ * delegates to synchronously) rather than the public `chat`: traceloop wraps
+ * `chat` and opens the span around it, so `__chat` runs while that span is the
+ * active span — letting this complement enrich it regardless of patch order.
+ */
+export declare class CohereChatTokenUsageInstrumentor {
+    private _patched;
+    instrument(): void;
+    uninstrument(): void;
+    private _wrap;
+}