weflayr 0.24.0 → 0.26.1

package/dist/src/instrumentation/anthropic/get_streaming_accumulation_telemetry.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Streamed-accumulation gap filling for the Anthropic chat span.
+ *
+ * `@traceloop/instrumentation-anthropic` accumulates a streamed response into a
+ * result object but drops two things on the way:
+ *   - the `message_delta` chunk's `delta.stop_reason`, so streamed spans format
+ *     their output message with an empty `finish_reason`, and
+ *   - the `content_block_delta` chunks' `input_json_delta` fragments, so a
+ *     streamed tool call's `tool_call` part carries no `arguments`.
+ *
+ * `_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 both — which are then
+ * injected into the accumulated result just before `_endSpan` formats the
+ * output message.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicStreamingAccumulationInstrumentor = void 0;
+class AnthropicStreamingAccumulationInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // span -> what upstream's accumulator dropped from that span's stream.
+    _gapsBySpan = new WeakMap();
+    // No-op (and never throws) if the instrumentor's internals have changed shape —
+    // the worst case is an unenriched streamed span, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const gapsBySpan = this._gapsBySpan;
+        function gapsFor(span) {
+            let gaps = gapsBySpan.get(span);
+            if (!gaps) {
+                gaps = { toolArgumentsJsonByIndex: new Map() };
+                gapsBySpan.set(span, gaps);
+            }
+            return gaps;
+        }
+        async function* observeDroppedChunks(stream, span) {
+            for await (const chunk of stream) {
+                try {
+                    if (chunk &&
+                        chunk.type === 'message_delta' &&
+                        chunk.delta &&
+                        chunk.delta.stop_reason != null) {
+                        gapsFor(span).stopReason = chunk.delta.stop_reason;
+                    }
+                    if (chunk &&
+                        chunk.type === 'content_block_delta' &&
+                        chunk.delta &&
+                        chunk.delta.type === 'input_json_delta' &&
+                        typeof chunk.delta.partial_json === 'string') {
+                        const argumentsByIndex = gapsFor(span).toolArgumentsJsonByIndex;
+                        argumentsByIndex.set(chunk.index, (argumentsByIndex.get(chunk.index) ?? '') + chunk.delta.partial_json);
+                    }
+                }
+                catch {
+                    // Never break the caller's stream over an enrichment failure.
+                }
+                yield chunk;
+            }
+        }
+        const streamOriginal = instrumentation._streamingWrapPromise;
+        if (typeof streamOriginal === 'function') {
+            instrumentation._streamingWrapPromise = function streamObservingDroppedChunks(client, moduleExports, opts) {
+                const span = opts && opts.span;
+                if (!span || !moduleExports || typeof moduleExports.APIPromise !== 'function') {
+                    return streamOriginal.call(this, client, moduleExports, opts);
+                }
+                class APIPromiseObservingDroppedChunks 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(() => observeDroppedChunks(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: APIPromiseObservingDroppedChunks, 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 endSpanWithDroppedChunks(args) {
+                try {
+                    const gaps = args && args.span && gapsBySpan.get(args.span);
+                    if (gaps && args.result) {
+                        if (gaps.stopReason != null && args.result.stop_reason == null) {
+                            args.result.stop_reason = gaps.stopReason;
+                        }
+                        for (const [index, argumentsJson] of gaps.toolArgumentsJsonByIndex) {
+                            const block = Array.isArray(args.result.content) && args.result.content[index];
+                            // Only fill the gap: a block whose input upstream DID accumulate
+                            // (a future version) is left alone.
+                            if (block &&
+                                block.type === 'tool_use' &&
+                                (!block.input || !Object.keys(block.input).length)) {
+                                try {
+                                    block.input = JSON.parse(argumentsJson);
+                                }
+                                catch {
+                                    // Truncated argument JSON: leave the block as upstream built it.
+                                }
+                            }
+                        }
+                    }
+                }
+                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 = [];
+    }
+}
+exports.AnthropicStreamingAccumulationInstrumentor = AnthropicStreamingAccumulationInstrumentor;

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

@@ -0,0 +1,9 @@
+/**
+ * Structured-output schema location for Anthropic requests.
+ *
+ * Anthropic pins an answer to a JSON schema with
+ * `output_config: { format: { type: 'json_schema', schema } }`. The traceloop
+ * instrumentor records neither that field nor the older top-level
+ * `output_format` - and Anthropic bills the schema as input.
+ */
+export declare function readStructuredOutputSchema(params: any): unknown;

package/dist/src/instrumentation/anthropic/get_structured_output_schema_telemetry.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Structured-output schema location for Anthropic requests.
+ *
+ * Anthropic pins an answer to a JSON schema with
+ * `output_config: { format: { type: 'json_schema', schema } }`. The traceloop
+ * instrumentor records neither that field nor the older top-level
+ * `output_format` - and Anthropic bills the schema as input.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStructuredOutputSchema = readStructuredOutputSchema;
+function readStructuredOutputSchema(params) {
+    const format = params && params.output_config && params.output_config.format;
+    if (!format || format.type !== 'json_schema')
+        return undefined;
+    return format.schema;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+export declare class AnthropicToolDefinitionsInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

package/dist/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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicToolDefinitionsInstrumentor = void 0;
+class AnthropicToolDefinitionsInstrumentor {
+    // [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 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) {
+                    // cache_control is dropped from the stamped definitions — the
+                    // breakpoint is captured separately in cache_config.
+                    const definitions = tools.map(({ cache_control: _cacheControl, ...definition }) => definition);
+                    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', startSpanOriginal]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.AnthropicToolDefinitionsInstrumentor = AnthropicToolDefinitionsInstrumentor;

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

@@ -0,0 +1,15 @@
+/**
+ * Anthropic telemetry complement — the registered orchestrator.
+ *
+ * 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), the request's tool
+ * definitions and structured-output schema, and the streamed stop reason and
+ * tool-call arguments (its stream accumulator drops both).
+ */
+export declare class AnthropicTelemetryInstrumentor {
+    private _subInstrumentors;
+    constructor();
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Anthropic telemetry complement — the registered orchestrator.
+ *
+ * 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), the request's tool
+ * definitions and structured-output schema, and the streamed stop reason and
+ * tool-call arguments (its stream accumulator drops both).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicTelemetryInstrumentor = void 0;
+const get_structured_output_schema_telemetry_1 = require("../shared/get_structured_output_schema_telemetry");
+const get_cache_config_telemetry_1 = require("./get_cache_config_telemetry");
+const get_cache_and_reasoning_telemetry_1 = require("./get_cache_and_reasoning_telemetry");
+const get_streaming_accumulation_telemetry_1 = require("./get_streaming_accumulation_telemetry");
+const get_tool_definitions_telemetry_1 = require("./get_tool_definitions_telemetry");
+const get_structured_output_schema_telemetry_2 = require("./get_structured_output_schema_telemetry");
+class AnthropicTelemetryInstrumentor {
+    _subInstrumentors;
+    constructor() {
+        this._subInstrumentors = [
+            new get_cache_and_reasoning_telemetry_1.AnthropicPromptCachingInstrumentor(),
+            new get_cache_config_telemetry_1.AnthropicCacheConfigInstrumentor(),
+            new get_streaming_accumulation_telemetry_1.AnthropicStreamingAccumulationInstrumentor(),
+            new get_tool_definitions_telemetry_1.AnthropicToolDefinitionsInstrumentor(),
+            new get_structured_output_schema_telemetry_1.TraceloopStructuredOutputSchemaInstrumentor(get_structured_output_schema_telemetry_2.readStructuredOutputSchema),
+        ];
+    }
+    instrument(instrumentation) {
+        for (const sub of this._subInstrumentors)
+            sub.instrument(instrumentation);
+    }
+    uninstrument() {
+        for (const sub of this._subInstrumentors)
+            sub.uninstrument();
+    }
+}
+exports.AnthropicTelemetryInstrumentor = AnthropicTelemetryInstrumentor;

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

@@ -0,0 +1,22 @@
+/**
+ * Request-side prompt-caching config capture for Bedrock invoke_model spans.
+ *
+ * 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
+ * native Anthropic shape), Amazon Nova bodies carry `cachePoint` blocks (the
+ * Converse shape) — on system entries, message content blocks or tool
+ * definitions, each with an optional raw `ttl` string ("5m"/"1h"). The
+ * traceloop instrumentor never records them.
+ *
+ * Wrap the instrumentor's `_startSpan({ params })` (params.body is the raw
+ * 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.
+ */
+import { type CacheBreakpoint } from '../anthropic/get_cache_config_telemetry';
+export declare function extractBedrockCacheBreakpoints(body: any): CacheBreakpoint[];
+export declare class BedrockCacheConfigInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Request-side prompt-caching config capture for Bedrock invoke_model spans.
+ *
+ * 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
+ * native Anthropic shape), Amazon Nova bodies carry `cachePoint` blocks (the
+ * Converse shape) — on system entries, message content blocks or tool
+ * definitions, each with an optional raw `ttl` string ("5m"/"1h"). The
+ * traceloop instrumentor never records them.
+ *
+ * Wrap the instrumentor's `_startSpan({ params })` (params.body is the raw
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockCacheConfigInstrumentor = void 0;
+exports.extractBedrockCacheBreakpoints = extractBedrockCacheBreakpoints;
+const get_cache_config_telemetry_1 = require("../anthropic/get_cache_config_telemetry");
+const BREAKPOINTS_ATTR = 'weflayr.cache.breakpoints';
+// A breakpoint as location + the raw `cachePoint` `ttl` string, omitted when
+// the request sets none.
+function _cachePointEntry(location, cachePoint) {
+    const ttl = cachePoint && cachePoint.ttl;
+    return ttl ? { location, ttl: String(ttl) } : { location };
+}
+// The first `cachePoint` among a list of blocks (attached to a content block,
+// or standing alone as its own block), or undefined.
+function _cachePointOfBlocks(blocks) {
+    if (!Array.isArray(blocks))
+        return undefined;
+    const block = blocks.find((entry) => entry && entry.cachePoint != null);
+    return block && block.cachePoint;
+}
+// Every cache breakpoint in an InvokeModel request body, as location + the
+// raw `ttl` string (omitted when the breakpoint sets none): the
+// Anthropic-on-Bedrock `cache_control` shape and the Nova `cachePoint` shape
+// (which never overlap in one body).
+function extractBedrockCacheBreakpoints(body) {
+    const breakpoints = (0, get_cache_config_telemetry_1.extractCacheBreakpoints)(body);
+    const systemCachePoint = _cachePointOfBlocks(body.system);
+    if (systemCachePoint != null) {
+        breakpoints.push(_cachePointEntry('system', systemCachePoint));
+    }
+    (body.messages || []).forEach((message, index) => {
+        const cachePoint = _cachePointOfBlocks(message && message.content);
+        if (cachePoint != null) {
+            breakpoints.push(_cachePointEntry(`messages[${index}]`, cachePoint));
+        }
+    });
+    const tools = (body.toolConfig && body.toolConfig.tools) || [];
+    tools.forEach((tool, index) => {
+        if (tool && tool.cachePoint != null) {
+            breakpoints.push(_cachePointEntry(`tools[${index}]`, tool.cachePoint));
+        }
+    });
+    return breakpoints;
+}
+class BedrockCacheConfigInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals have changed shape —
+    // the worst case is missing cache-config capture, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        const startSpanOriginal = instrumentation._startSpan;
+        if (typeof startSpanOriginal !== 'function')
+            return;
+        instrumentation._startSpan = function startSpanWithCacheConfig(request) {
+            const span = startSpanOriginal.call(this, request);
+            try {
+                const rawBody = request && request.params && request.params.input && request.params.input.body;
+                if (typeof rawBody === 'string' || rawBody instanceof Uint8Array) {
+                    const body = JSON.parse(typeof rawBody === 'string' ? rawBody : new TextDecoder().decode(rawBody));
+                    const breakpoints = extractBedrockCacheBreakpoints(body || {});
+                    if (breakpoints.length) {
+                        span.setAttribute(BREAKPOINTS_ATTR, JSON.stringify(breakpoints));
+                    }
+                }
+            }
+            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 = [];
+    }
+}
+exports.BedrockCacheConfigInstrumentor = BedrockCacheConfigInstrumentor;

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

@@ -0,0 +1,22 @@
+/**
+ * Cached-prompt token enrichment complement for the Bedrock invoke_model path.
+ *
+ * `@traceloop/instrumentation-bedrock` records `gen_ai.usage.{input,output}_tokens`
+ * off the InvokeModel response body but never reads its cache-token counts, so
+ * spans for prompt-cache hits carry no cached-token figures. Amazon Nova's native
+ * InvokeModel response includes `usage.cacheReadInputTokenCount` /
+ * `usage.cacheWriteInputTokenCount` (Anthropic-on-Bedrock responses carry the
+ * native `usage.cache_read_input_tokens` / `cache_creation_input_tokens`);
+ * this maps them to the
+ * `gen_ai.usage.cache_read_input_tokens` / `cache_creation_input_tokens`
+ * attributes the worker reads, matching the Python SDK.
+ *
+ * It wraps the instrumentor instance's `_wrapPromise(span, promise, modelId)`,
+ * which resolves the send promise and enriches the span before ending it,
+ * letting us read the decoded body off the same response while the span is open.
+ */
+export declare class BedrockPromptCachingInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Cached-prompt token enrichment complement for the Bedrock invoke_model path.
+ *
+ * `@traceloop/instrumentation-bedrock` records `gen_ai.usage.{input,output}_tokens`
+ * off the InvokeModel response body but never reads its cache-token counts, so
+ * spans for prompt-cache hits carry no cached-token figures. Amazon Nova's native
+ * InvokeModel response includes `usage.cacheReadInputTokenCount` /
+ * `usage.cacheWriteInputTokenCount` (Anthropic-on-Bedrock responses carry the
+ * native `usage.cache_read_input_tokens` / `cache_creation_input_tokens`);
+ * this maps them to the
+ * `gen_ai.usage.cache_read_input_tokens` / `cache_creation_input_tokens`
+ * attributes the worker reads, matching the Python SDK.
+ *
+ * It wraps the instrumentor instance's `_wrapPromise(span, promise, modelId)`,
+ * which resolves the send promise and enriches the span before ending it,
+ * letting us read the decoded body off the same response while the span is open.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockPromptCachingInstrumentor = void 0;
+const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read_input_tokens';
+const CACHE_CREATION_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_creation_input_tokens';
+// Stamp cache counts from a `usage` object onto the span: Nova's camelCase
+// count fields, or Anthropic-on-Bedrock's native snake_case ones.
+function _setCacheFromUsage(span, usage) {
+    if (!usage || !span || !span.isRecording || !span.isRecording())
+        return;
+    const read = usage.cacheReadInputTokenCount ?? usage.cache_read_input_tokens;
+    const write = usage.cacheWriteInputTokenCount ?? usage.cache_creation_input_tokens;
+    if (typeof read === 'number' && read) {
+        span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, read);
+    }
+    if (typeof write === 'number' && write) {
+        span.setAttribute(CACHE_CREATION_INPUT_TOKENS_ATTR, write);
+    }
+}
+function _setCacheTokens(span, response) {
+    if (!span || !span.isRecording || !span.isRecording())
+        return;
+    const body = response && response.body;
+    // Only the non-streaming InvokeModel response buffers its body as bytes; a
+    // response stream is an async iterable whose usage arrives in a trailing chunk
+    // handled by the streaming wrap below, so skip it here (and never consume the
+    // caller's stream).
+    if (!body || typeof body[Symbol.asyncIterator] === 'function')
+        return;
+    try {
+        _setCacheFromUsage(span, JSON.parse(new TextDecoder().decode(body)).usage);
+    }
+    catch {
+        // Never break span enrichment over a parse failure.
+    }
+}
+class BedrockPromptCachingInstrumentor {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals have changed shape —
+    // the worst case is missing cached-token counts, never a crash.
+    instrument(instrumentation) {
+        if (!instrumentation)
+            return;
+        // Non-streamed: enrich the buffered InvokeModel response body.
+        const wrapPromiseOriginal = instrumentation._wrapPromise;
+        if (typeof wrapPromiseOriginal === 'function') {
+            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.
+                const enriched = Promise.resolve(promise).then((response) => {
+                    _setCacheTokens(span, response);
+                    return response;
+                });
+                return wrapPromiseOriginal.call(this, span, enriched, modelId);
+            };
+            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.
+        const metadataOriginal = instrumentation._handleNovaStreamingMetadata;
+        if (typeof metadataOriginal === 'function') {
+            instrumentation._handleNovaStreamingMetadata = function handleMetadataWithCache(span, parsedResponse) {
+                try {
+                    const usage = parsedResponse && parsedResponse.metadata && parsedResponse.metadata.usage;
+                    _setCacheFromUsage(span, usage);
+                }
+                catch {
+                    // Never break the caller's stream over an enrichment failure.
+                }
+                return metadataOriginal.call(this, span, parsedResponse);
+            };
+            this._patched.push([instrumentation, '_handleNovaStreamingMetadata', metadataOriginal]);
+        }
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.BedrockPromptCachingInstrumentor = BedrockPromptCachingInstrumentor;

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

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+export declare class BedrockInputMessageContentInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

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

@@ -0,0 +1,91 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockInputMessageContentInstrumentor = void 0;
+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 {
+    // [instrumentation, methodName, originalFunction] for uninstrument().
+    _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 = [];
+    }
+}
+exports.BedrockInputMessageContentInstrumentor = BedrockInputMessageContentInstrumentor;