@struct-ai/sdk 0.3.0 → 0.4.2

package/dist/esm/integrations/anthropic.js

@@ -1,5 +1,5 @@
 import { SpanKind, SpanStatusCode, context as otelContext, trace, } from "@opentelemetry/api";
-import { ensurePendingToolCallsSlot, getAgentSpan, getSessionId, pushPendingToolCalls, runWithStore, snapshotStore, } from "../context.js";
+import { ensurePendingToolCallsSlot, getAgentSpan, getSessionId, propagateProviderToParent, isGenAiSuppressed, pushPendingToolCalls, runWithContext, runWithStore, snapshotStore, } from "../context.js";
 function childParentContext() {
     const agentSpan = getAgentSpan();
     return agentSpan
@@ -7,9 +7,11 @@ function childParentContext() {
         : otelContext.active();
 }
 import { safe } from "../core.js";
+import { detectProviderFromResource, } from "../genai-content.js";
 import { emitAnthropicChoiceEvent, emitAnthropicMessageEvents, } from "../events.js";
+import { propagateUserPromptToParent as sharedPropagateUserPromptToParent } from "../genai-content.js";
+import { instrumentCall } from "../instrument.js";
 import { ERROR_TYPE, GEN_AI, STRUCT, } from "../semconv.js";
-import { truncateAndSerialize } from "../truncation.js";
 import { iterToolUses, lastUserMessageParts, safeJsonForTool, toInputMessages, toOutputMessages, toSystemInstructions, } from "./anthropic-content.js";
 const STRUCT_WRAPPED = Symbol.for("struct.wrapped");
 const STRUCT_ORIGINAL = Symbol.for("struct.original");
@@ -97,65 +99,124 @@ function restoreMethod(proto, methodName) {
         proto[methodName] = current[STRUCT_ORIGINAL];
     }
 }
-function wrapCreate(original) {
+// Exact client class names per platform (prototype chain covers subclasses)
+// and official endpoint host shapes only — a generic cloud host (API-gateway,
+// storage, arbitrary *.amazonaws.com/*.googleapis.com proxies) is NOT
+// platform routing and must stay on the fallback. Parity: python anthropic.py.
+const CLASS_NAME_RULES = [
+    // Mantle flavor extends BaseMantleClient, NOT the plain Bedrock base, so it
+    // needs its own names; default endpoint bedrock-mantle.{region}.api.aws.
+    [
+        new Set([
+            "AnthropicBedrock",
+            "BaseAnthropicBedrock",
+            "AnthropicBedrockMantle",
+            "BaseMantleClient",
+        ]),
+        "aws.bedrock",
+    ],
+    [new Set(["AnthropicVertex", "BaseAnthropicVertex"]), "gcp.vertex_ai"],
+];
+function isBedrockHost(host) {
+    if ((host.startsWith("bedrock-runtime.") ||
+        host.startsWith("bedrock-runtime-fips.")) &&
+        (host.endsWith(".amazonaws.com") || host.endsWith(".amazonaws.com.cn"))) {
+        return true;
+    }
+    // Bedrock Mantle default endpoint: bedrock-mantle.{region}.api.aws
+    return host.startsWith("bedrock-mantle.") && host.endsWith(".api.aws");
+}
+function isVertexHost(host) {
+    return (host === "aiplatform.googleapis.com" ||
+        host.endsWith("-aiplatform.googleapis.com"));
+}
+const HOST_RULES = [
+    [isBedrockHost, "aws.bedrock"],
+    [isVertexHost, "gcp.vertex_ai"],
+];
+function detectProvider(resource) {
+    return detectProviderFromResource(resource, CLASS_NAME_RULES, HOST_RULES, "anthropic");
+}
+/** @internal */
+export const _detectProviderForTest = detectProvider;
+/** @internal */
+export const _setChatRequestAttrsForTest = (span, params, sdk, logger, provider) => setChatRequestAttrs(span, params, sdk, logger, provider);
+export function wrapCreate(original) {
     return function wrappedCreate(params, opts) {
         const patchCtx = activePatchCtx.value;
         if (!patchCtx) {
             return original.call(this, params, opts);
         }
+        // CLASS RULE: detection => propagation, immediately and on EVERY path
+        // (see openai.ts). Guarded; write-once makes repeats harmless.
+        const provider = detectProvider(this);
+        propagateProviderToParent(provider);
+        if (isGenAiSuppressed()) {
+            // A framework layer owns this chat span — run the call, emit no span.
+            return original.call(this, params, opts);
+        }
+        // Preflight reads touch CALLER-owned `params` — a Proxy / lazy request
+        // object can have throwing getters; a throw here would prevent the API
+        // call. Degrade: exactly one plain, uninstrumented original.call.
+        let streaming = false;
+        let model = "unknown";
+        try {
+            streaming = !!(params && params.stream === true);
+            model = params?.model ?? "unknown";
+        }
+        catch {
+            return original.call(this, params, opts);
+        }
         // If params.stream is true, Messages.create delegates to the streaming path.
         // We still need to instrument the returned stream like we do in messages.stream.
-        if (params && params.stream === true) {
+        if (streaming) {
             return wrapStream(original).call(this, params, opts);
         }
         const { tracer, sdk, logger } = patchCtx;
-        const internalLogger = sdk.getInternalLogger();
-        const model = params?.model ?? "unknown";
-        // Span creation itself can fail (custom tracer, broken context). If it
-        // does, fall through to calling `original` directly so the user's API
-        // call always runs. Mirrors the Python `_wrap_create` fall-through.
-        let span;
-        let ctx;
-        safe(() => {
-            const parentCtx = childParentContext();
-            span = tracer.startSpan(`chat ${model}`, { kind: SpanKind.CLIENT }, parentCtx);
-            ctx = trace.setSpan(parentCtx, span);
-        }, "anthropic.create.start_span", internalLogger);
-        if (!span || !ctx) {
-            return original.call(this, params, opts);
-        }
-        const liveSpan = span;
-        const liveCtx = ctx;
-        // Enter the span's context BEFORE emitting request-side log records so
-        // `logger.emit({ context: otelContext.active() })` picks up the chat
-        // span as the log's TraceId / SpanId. Without this the UI can't link
-        // user/system message logs back to the chat span.
-        return otelContext.with(liveCtx, () => {
-            safe(() => setChatRequestAttrs(liveSpan, params, sdk, logger), "anthropic.create.set_request_attrs", internalLogger);
-            const promise = Promise.resolve(original.call(this, params, opts));
-            return promise.then((result) => {
-                safe(() => setChatResponseAttrs(liveSpan, sdk, result, logger), "anthropic.create.set_response_attrs", internalLogger);
-                safe(() => liveSpan.setStatus({ code: SpanStatusCode.OK }), "anthropic.create.set_ok_status", internalLogger);
-                safe(() => liveSpan.end(), "anthropic.create.span_end", internalLogger);
-                return result;
-            }, (err) => {
-                safe(() => recordErrorOnSpan(liveSpan, err), "anthropic.create.record_error", internalLogger);
-                safe(() => liveSpan.end(), "anthropic.create.span_end_on_error", internalLogger);
-                // User's API exception always propagates unchanged.
-                throw err;
-            });
+        // All host-boundary safety lives in the shared instrumentCall harness: the
+        // host call runs exactly once, nothing host-controllable wraps it, and every
+        // telemetry side-effect degrades via safe(). Log-record→span linkage is
+        // carried by the explicit span passed to the emitters, so no
+        // `otelContext.with(...)` is needed around the call.
+        return instrumentCall(() => original.call(this, params, opts), {
+            tracer,
+            spanName: `chat ${model}`,
+            spanKind: SpanKind.CLIENT,
+            parentContext: childParentContext,
+            sitePrefix: "anthropic.create",
+            internalLogger: sdk.getInternalLogger(),
+            onStart: (span) => setChatRequestAttrs(span, params, sdk, logger, provider),
+            onSuccess: (span, result) => setChatResponseAttrs(span, sdk, result, logger, provider),
+            onError: (span, err) => recordErrorOnSpan(span, err),
         });
     };
 }
-function wrapStream(original) {
+export function wrapStream(original) {
     return function wrappedStream(params, opts) {
         const patchCtx = activePatchCtx.value;
         if (!patchCtx) {
             return original.call(this, params, opts);
         }
+        // CLASS RULE: detection => propagation, immediately and on EVERY path —
+        // when suppressed (langchain owns the span), the raw client here is the
+        // only layer that can detect the real platform for the agent span.
+        const streamProvider = detectProvider(this);
+        propagateProviderToParent(streamProvider);
+        if (isGenAiSuppressed()) {
+            // A framework layer owns this chat span — run the call, emit no span.
+            return original.call(this, params, opts);
+        }
         const { tracer, sdk, logger } = patchCtx;
         const internalLogger = sdk.getInternalLogger();
-        const model = params?.model ?? "unknown";
+        // Preflight read of CALLER-owned params — a throwing `model` getter must
+        // degrade to one plain uninstrumented call, never block the stream.
+        let model = "unknown";
+        try {
+            model = params?.model ?? "unknown";
+        }
+        catch {
+            return original.call(this, params, opts);
+        }
         // Span creation itself can fail. If it does, fall through to calling
         // `original` directly so the user's stream call always runs. Mirrors
         // the Python `_wrap_stream` fall-through pattern.
@@ -172,13 +233,6 @@ function wrapStream(original) {
         const liveSpan = span;
         const liveCtx = ctx;
         const storeSnapshot = snapshotStore();
-        // Enter the span's context BEFORE request-side log emission so logs
-        // link back to the chat span via TraceId. Same rationale as wrapCreate.
-        // @anthropic-ai/sdk's `stream()` returns a MessageStream synchronously.
-        const stream = otelContext.with(liveCtx, () => {
-            safe(() => setChatRequestAttrs(liveSpan, params, sdk, logger), "anthropic.stream.set_request_attrs", internalLogger);
-            return original.call(this, params, opts);
-        });
         let finalized = false;
         const finalize = (result, err) => {
             if (finalized)
@@ -189,7 +243,7 @@ function wrapStream(original) {
                     safe(() => recordErrorOnSpan(liveSpan, err), "anthropic.stream.record_error", internalLogger);
                 }
                 else if (result) {
-                    safe(() => otelContext.with(liveCtx, () => setChatResponseAttrs(liveSpan, sdk, result, logger)), "anthropic.stream.set_response_attrs", internalLogger);
+                    safe(() => otelContext.with(liveCtx, () => setChatResponseAttrs(liveSpan, sdk, result, logger, streamProvider)), "anthropic.stream.set_response_attrs", internalLogger);
                     safe(() => liveSpan.setStatus({ code: SpanStatusCode.OK }), "anthropic.stream.set_ok_status", internalLogger);
                 }
                 else {
@@ -198,48 +252,416 @@ function wrapStream(original) {
                 safe(() => liveSpan.end(), "anthropic.stream.span_end", internalLogger);
             });
         };
-        const ee = stream;
-        if (ee && typeof ee.on === "function") {
-            ee.on("finalMessage", (msg) => {
-                finalize(msg, undefined);
-            });
-            ee.on("error", (err) => {
-                finalize(undefined, err);
-            });
-            // If the stream is created and never iterated / finalized, at least
-            // don't hang on test exit — "end" fires after iteration completes.
-            ee.on("end", () => {
-                // Only fires if no finalMessage / error fired first (rare path).
+        // Enter the span's context BEFORE request-side log emission so logs
+        // link back to the chat span via TraceId. Same rationale as wrapCreate.
+        // @anthropic-ai/sdk's `stream()` returns a MessageStream synchronously,
+        // but `messages.create({stream:true})` (delegated here from wrapCreate)
+        // returns an APIPromise-like thenable resolving to a raw event Stream —
+        // both shapes are handled below.
+        //
+        // Suppress nested instrumentation: the real `Messages.prototype.stream()`
+        // (`original` here) internally calls `MessageStream.createMessage`, whose
+        // executor synchronously invokes `messages.create({ ...params, stream:
+        // true }, ...)` — on the SAME patched `Messages` prototype — before its
+        // first `await` yields control. That resolves to our `wrapCreate`
+        // wrapper, which would otherwise see `params.stream === true` and
+        // re-delegate to a brand-new `wrapStream(original)`, instrumenting the
+        // same underlying raw stream a second time (2 chat spans, same
+        // gen_ai.response.id). `runWithContext({ suppressGenAi: true }, ...)`
+        // scopes an ALS store patch around exactly this synchronous call (plus
+        // any promise chain it kicks off internally, since AsyncLocalStorage
+        // propagates into `.then` continuations created within the `run()`
+        // callback) — `wrapCreate` checks `isGenAiSuppressed()` before its
+        // `stream === true` branch and, when suppressed, falls through to
+        // calling the TRUE raw `create` directly (no span, no re-wrap). This
+        // must NOT leak into user code: the store patch is popped the instant
+        // `original.call(...)` returns (it returns the MessageStream
+        // synchronously), so by the time control returns to the caller of
+        // `.stream()`, suppression is already off again — user code that later
+        // iterates the stream, or that itself calls `messages.create`/`.stream`,
+        // runs with a clean (unsuppressed) ALS store.
+        let stream;
+        try {
+            safe(() => setChatRequestAttrs(liveSpan, params, sdk, logger, streamProvider), "anthropic.stream.set_request_attrs", internalLogger);
+            // `suppressGenAi` is ALS-based (`als.run`), NOT host-controllable, so it
+            // may wrap the original stream call. We deliberately do NOT wrap it in
+            // `otelContext.with(liveCtx, ...)`: a customer's global ContextManager
+            // could throw there and block the stream (host-fault). Log-record→span
+            // linkage is carried by the explicit span passed inside
+            // setChatRequestAttrs, not by ambient context.
+            stream = runWithContext({ suppressGenAi: true }, () => original.call(this, params, opts));
+        }
+        catch (err) {
+            // Sync throw from the original call would otherwise leak the span —
+            // no stream/promise is ever produced to drive finalize() below.
+            finalize(undefined, err);
+            throw err;
+        }
+        // The entire branch-dispatch region below — reading `ee.on`/`.then`/
+        // `Symbol.asyncIterator`, registering `.on(...)` listeners, invoking
+        // `.then(...)`, and calling `instrumentSyncIterable` — runs SYNCHRONOUSLY
+        // on the success path of the customer's `.stream()`/`.create()` call, and
+        // was previously unguarded (round-4 only hardened the ASYNC observer
+        // callbacks registered inside it, e.g. the onFulfilled/onRejected
+        // handlers below). A hostile/broken stream-like object — a throwing
+        // `.on`/`.then`/`Symbol.asyncIterator` getter, or a `.on()` registration
+        // call that itself throws — would throw synchronously OUT of the
+        // customer's call. Wrap the whole dispatch in try/catch so a successful
+        // request never becomes a hard failure purely because OUR observer
+        // wiring couldn't attach: degrade to no telemetry and hand back the
+        // ORIGINAL stream object unchanged.
+        try {
+            const ee = stream;
+            // Emitter path wins first — a real MessageStream (`.on`) is never
+            // thenable, but check `.on` before `.then` defensively in case some
+            // future stream shape exposes both.
+            if (ee && typeof ee.on === "function") {
+                ee.on("finalMessage", (msg) => {
+                    finalize(msg, undefined);
+                });
+                ee.on("error", (err) => {
+                    finalize(undefined, err);
+                });
+                // Abort fires before "end" on an aborted stream — without this
+                // listener the "end" handler below finalizes with OK status even
+                // though the request was aborted. `finalized` makes the subsequent
+                // "end" a no-op.
+                ee.on("abort", (err) => {
+                    finalize(undefined, err ?? new Error("aborted"));
+                });
+                // If the stream is created and never iterated / finalized, at least
+                // don't hang on test exit — "end" fires after iteration completes.
+                ee.on("end", () => {
+                    // Only fires if no finalMessage / error / abort fired first (rare
+                    // path for a healthy, fully-drained stream).
+                    finalize(undefined, undefined);
+                });
+            }
+            else if (ee && typeof ee.then === "function") {
+                // `create({stream:true})` shape: an APIPromise-like thenable that
+                // resolves to a raw event Stream (no `.on`, no synchronous
+                // asyncIterator until resolved). Observe the resolution to instrument
+                // the resolved Stream BY MUTATION, but return the ORIGINAL thenable —
+                // Anthropic's APIPromise exposes methods like `.withResponse()` /
+                // `.asResponse()` that a native `Promise.resolve(...).then(...)` would
+                // strip, breaking customer code only when instrumentation is enabled.
+                // Our observer registers synchronously here, before the caller can
+                // await, so instrumentRawStream mutates the same resolved object the
+                // caller receives, before they iterate it.
+                const thenable = stream;
+                const observerChain = thenable.then((raw) => {
+                    // instrumentRawStream can itself throw at points outside its OWN
+                    // internal try/catch (e.g. a hostile `Symbol.asyncIterator`
+                    // getter, read before that internal guard) — this must not
+                    // escape THIS onFulfilled callback: an uncaught throw here
+                    // becomes an unhandled rejection on the promise `.then()`
+                    // returns, even though the customer's original APIPromise
+                    // resolved successfully — a successful request must never crash
+                    // the host. Degrade: end the span with no telemetry and swallow.
+                    try {
+                        instrumentRawStream(raw);
+                    }
+                    catch {
+                        finalize(undefined, undefined);
+                    }
+                }, (err) => {
+                    // Observe the rejection to finalize the span, but do NOT rethrow:
+                    // this observer branch must never surface as an unhandled
+                    // rejection. The original thenable still rejects to the caller
+                    // independently.
+                    finalize(undefined, err);
+                });
+                // Belt-and-suspenders: both branches above are already guarded to
+                // never throw/reject, so this derived promise should never reject —
+                // but chain a no-op `.catch` anyway so this internal observer chain
+                // can NEVER become an unhandled-rejection source, even under future
+                // edits to the branches above.
+                observerChain.catch?.(() => { });
+                return stream;
+            }
+            else if (ee && typeof ee[Symbol.asyncIterator] === "function") {
+                // Wrap the async iterator so each .next() runs inside the captured
+                // ALS store.
+                instrumentSyncIterable(ee);
+            }
+            return stream;
+        }
+        catch {
+            finalize(undefined, undefined);
+            return stream;
+        }
+        function instrumentRawStream(raw) {
+            const it = raw;
+            if (!it || typeof it[Symbol.asyncIterator] !== "function") {
+                finalize(undefined, undefined); // not iterable — end the span rather than leak it
+                return raw;
+            }
+            // A raw stream that is awaited but never iterated would otherwise leak
+            // its span — finalize() only fires through the iterator hooks below.
+            // Anthropic's Stream carries an AbortController; close the span if the
+            // request is aborted before/without iteration. Residual (documented,
+            // accepted): a stream awaited, never iterated, AND never aborted stays
+            // open until process exit — no lifecycle signal exists to close it.
+            //
+            // This whole section reads a `controller` getter and calls
+            // `addEventListener` on whatever object the SDK (or a hostile/broken
+            // caller-supplied stand-in) hands us — both are fallible and, unlike
+            // the `Symbol.asyncIterator` assignment below, were previously
+            // unguarded. Wrap it so a throwing getter degrades to "no abort-driven
+            // finalize wiring" rather than aborting instrumentRawStream entirely
+            // (which would also skip the Symbol.asyncIterator instrumentation
+            // below and lose the whole stream's telemetry, not just the abort
+            // hook). The caller (the observer's onFulfilled, or the synchronous
+            // `.on()`/asyncIterator paths in wrapStream) also guards its own call
+            // to instrumentRawStream, so this is defense-in-depth, not the only
+            // guard.
+            try {
+                const ctrl = raw.controller;
+                const sig = ctrl?.signal;
+                if (sig) {
+                    if (sig.aborted) {
+                        finalize(undefined, sig.reason ?? new Error("aborted"));
+                    }
+                    else {
+                        sig.addEventListener("abort", () => finalize(undefined, sig.reason ?? new Error("aborted")), { once: true });
+                    }
+                }
+            }
+            catch {
+                // Swallow — no abort-driven finalize wiring for this stream, but
+                // fall through to installing the Symbol.asyncIterator override
+                // below so normal iteration still drives accumulate()/finalize().
+            }
+            const acc = {};
+            const originalIter = it[Symbol.asyncIterator].bind(it);
+            try {
+                it[Symbol.asyncIterator] = () => {
+                    const inner = originalIter();
+                    return {
+                        next: () => runWithStore(storeSnapshot, () => inner.next().then((res) => {
+                            // accumulate()/accToResponseMessage() inspect provider-owned
+                            // values (a proxy getter can throw; accToResponseMessage
+                            // JSON.parses input_json_delta, which may be malformed). A
+                            // successfully yielded item must NEVER become a rejected
+                            // next(): on any instrumentation failure, degrade telemetry
+                            // (finalize with no result) and return the original res.
+                            try {
+                                if (!res.done)
+                                    accumulate(acc, res.value);
+                                else
+                                    finalize(accToResponseMessage(acc), undefined);
+                            }
+                            catch {
+                                finalize(undefined, undefined);
+                            }
+                            return res;
+                        }, (err) => {
+                            finalize(undefined, err);
+                            throw err;
+                        })),
+                        return: (v) => runWithStore(storeSnapshot, () => {
+                            // Settle the inner iterator's cleanup BEFORE finalizing, so a
+                            // cleanup rejection is recorded as ERROR rather than the span
+                            // being closed OK while the caller receives a rejection.
+                            const ret = inner.return
+                                ? inner.return(v)
+                                : Promise.resolve({ value: v, done: true });
+                            return Promise.resolve(ret).then((res) => {
+                                finalize(accToResponseMessage(acc), undefined); // early break — close OK
+                                return res;
+                            }, (err) => {
+                                finalize(undefined, err); // cleanup rejected — record ERROR
+                                throw err; // propagate the original rejection unchanged
+                            });
+                        }),
+                        throw: (e) => runWithStore(storeSnapshot, () => {
+                            // The thrown value IS the error condition, so finalize ERROR
+                            // with it regardless of the inner iterator's cleanup outcome.
+                            finalize(undefined, e);
+                            return inner.throw ? inner.throw(e) : Promise.reject(e);
+                        }),
+                    };
+                };
+            }
+            catch {
+                // The resolved stream object is frozen/sealed or the property is
+                // non-writable — assigning Symbol.asyncIterator threw. A successful
+                // request must never become a rejected promise because OUR
+                // instrumentation couldn't attach; degrade gracefully (end the span
+                // with no telemetry) and hand back the untouched object. No Proxy
+                // fallback — that would change the stream's identity, which is its
+                // own hazard.
                 finalize(undefined, undefined);
-            });
+            }
+            return raw;
         }
-        // Wrap the async iterator so each .next() runs inside the captured ALS store.
-        if (ee && typeof ee[Symbol.asyncIterator] === "function") {
-            const originalIter = ee[Symbol.asyncIterator].bind(ee);
-            ee[Symbol.asyncIterator] = () => {
-                const inner = originalIter();
-                const wrapped = {
-                    next() {
-                        return runWithStore(storeSnapshot, () => inner.next());
-                    },
-                    return(value) {
-                        return runWithStore(storeSnapshot, () => inner.return ? inner.return(value) : Promise.resolve({ value, done: true }));
-                    },
-                    throw(err) {
-                        return runWithStore(storeSnapshot, () => inner.throw
-                            ? inner.throw(err)
-                            : Promise.reject(err));
-                    },
+        function instrumentSyncIterable(target) {
+            const originalIter = target[Symbol.asyncIterator].bind(target);
+            try {
+                target[Symbol.asyncIterator] = () => {
+                    const inner = originalIter();
+                    const wrapped = {
+                        next() {
+                            return runWithStore(storeSnapshot, () => inner.next());
+                        },
+                        return(value) {
+                            return runWithStore(storeSnapshot, () => inner.return
+                                ? inner.return(value)
+                                : Promise.resolve({ value, done: true }));
+                        },
+                        throw(err) {
+                            return runWithStore(storeSnapshot, () => inner.throw ? inner.throw(err) : Promise.reject(err));
+                        },
+                    };
+                    return wrapped;
                 };
-                return wrapped;
+            }
+            catch {
+                // Same hazard class as instrumentRawStream above: the target is
+                // frozen/sealed or the property is non-writable. This call happens
+                // synchronously inside wrapStream itself (not inside a promise
+                // callback), so an uncaught throw here would surface as a
+                // SYNCHRONOUS exception out of the user's `.stream()`/`.create()`
+                // call — turning a successful request into a hard failure. Degrade
+                // gracefully instead: end the span with no telemetry and leave the
+                // iterable completely untouched (the failed assignment never took
+                // effect).
+                finalize(undefined, undefined);
+            }
+        }
+        function accumulate(acc, ev) {
+            const e = ev;
+            if (e?.type === "message_start" && e.message) {
+                acc.id = e.message.id;
+                acc.model = e.message.model;
+                acc.inputTokens = e.message.usage?.input_tokens;
+                // Cached `create({stream:true})` requests carry cache token counts
+                // on message_start's usage (never on message_delta's) — without
+                // these, the synthesized ResponseMessage under-reports input usage
+                // (setChatResponseAttrs adds them into the total) and omits both
+                // cache attributes entirely, unlike the non-streaming and
+                // MessageStream (`.on("finalMessage")`) paths, which pass the SDK's
+                // own parsed usage straight through.
+                acc.cacheReadTokens = e.message.usage?.cache_read_input_tokens;
+                acc.cacheCreationTokens = e.message.usage?.cache_creation_input_tokens;
+            }
+            else if (e?.type === "content_block_start" && typeof e.index === "number") {
+                // Assemble content blocks so the synthesized response carries
+                // `content` — without it, setChatResponseAttrs's `if (response.content)`
+                // block never runs on this raw-stream path, dropping
+                // gen_ai.output.messages, the gen_ai.choice event, and (critically)
+                // recordPendingToolCalls, so a streamed tool_use never links to its
+                // execute_tool span. Mirrors MessageStream's finalMessage assembly,
+                // minimally: text blocks and tool_use blocks only.
+                const blocks = (acc.blocks ??= {});
+                const cb = e.content_block;
+                if (cb?.type === "tool_use") {
+                    blocks[e.index] = {
+                        type: "tool_use",
+                        id: cb.id,
+                        name: cb.name,
+                        jsonBuf: "",
+                    };
+                }
+                else if (cb?.type === "text") {
+                    blocks[e.index] = { type: "text", text: cb.text ?? "" };
+                }
+                else if (cb?.type) {
+                    blocks[e.index] = { type: cb.type };
+                }
+            }
+            else if (e?.type === "content_block_delta" && typeof e.index === "number") {
+                const blocks = (acc.blocks ??= {});
+                const b = blocks[e.index];
+                if (!b)
+                    return;
+                if (e.delta?.type === "text_delta" && typeof e.delta.text === "string") {
+                    b.text = (b.text ?? "") + e.delta.text;
+                }
+                else if (e.delta?.type === "input_json_delta" &&
+                    typeof e.delta.partial_json === "string") {
+                    b.jsonBuf = (b.jsonBuf ?? "") + e.delta.partial_json;
+                }
+            }
+            else if (e?.type === "content_block_stop" && typeof e.index === "number") {
+                const blocks = (acc.blocks ??= {});
+                const b = blocks[e.index];
+                if (b?.type === "tool_use") {
+                    // Parse the accumulated partial_json into the tool_use input; fall
+                    // back to the raw string if the model streamed malformed JSON (the
+                    // block still links via id/name, which is what tool-call linkage
+                    // needs).
+                    try {
+                        b.input = b.jsonBuf ? JSON.parse(b.jsonBuf) : {};
+                    }
+                    catch {
+                        b.input = b.jsonBuf;
+                    }
+                }
+            }
+            else if (e?.type === "message_delta") {
+                if (e.delta?.stop_reason)
+                    acc.stopReason = e.delta.stop_reason;
+                if (e.usage?.output_tokens !== undefined) {
+                    acc.outputTokens = e.usage.output_tokens;
+                }
+            }
+        }
+        // NOTE (parity, intentional divergence — self-audit round 5, item G):
+        // this synthesizes a FULL ResponseMessage (content, usage, stop_reason,
+        // id, model) from the raw SSE event stream, matching what the
+        // non-streaming `create()` path and `MessageStream`'s `finalMessage`
+        // event already carry. struct-sdk-python's `create(stream=True)` raw
+        // path does NOT do this reconstruction yet and emits none of these
+        // response-side attributes for that one call shape. This is TS being
+        // MORE complete than Python here, not a TS bug — do not remove it to
+        // "match" Python. Bringing Python's raw-stream path up to parity is a
+        // separate, independent follow-up.
+        function accToResponseMessage(acc) {
+            const blocks = acc.blocks;
+            if (acc.id === undefined && acc.inputTokens === undefined && !blocks) {
+                return undefined;
+            }
+            // Rebuild content in ascending block index, shaped like the SDK's own
+            // parsed message content so setChatResponseAttrs / iterToolUses read it
+            // identically to the non-streaming path.
+            let content;
+            if (blocks) {
+                content = Object.keys(blocks)
+                    .map((k) => Number(k))
+                    .sort((a, b) => a - b)
+                    .map((i) => {
+                    const b = blocks[i];
+                    if (b.type === "tool_use") {
+                        return { type: "tool_use", id: b.id, name: b.name, input: b.input ?? {} };
+                    }
+                    if (b.type === "text") {
+                        return { type: "text", text: b.text ?? "" };
+                    }
+                    return { type: b.type };
+                });
+            }
+            return {
+                id: acc.id,
+                model: acc.model,
+                stop_reason: acc.stopReason,
+                content: content,
+                usage: {
+                    input_tokens: acc.inputTokens,
+                    output_tokens: acc.outputTokens,
+                    // Raw fields only — setChatResponseAttrs remains the single place
+                    // that adds these into the reported total, matching the
+                    // non-streaming/MessageStream contract exactly.
+                    cache_read_input_tokens: acc.cacheReadTokens,
+                    cache_creation_input_tokens: acc.cacheCreationTokens,
+                },
             };
         }
-        return stream;
     };
 }
-function setChatRequestAttrs(span, params, sdk, logger) {
+function setChatRequestAttrs(span, params, sdk, logger, provider = "anthropic") {
     span.setAttribute(GEN_AI.OPERATION_NAME, "chat");
-    span.setAttribute(GEN_AI.PROVIDER_NAME, "anthropic");
+    span.setAttribute(GEN_AI.PROVIDER_NAME, provider);
     const model = params?.model ?? "unknown";
     span.setAttribute(GEN_AI.REQUEST_MODEL, model);
     const sessionId = getSessionId();
@@ -263,10 +685,15 @@ function setChatRequestAttrs(span, params, sdk, logger) {
     }
     if (Array.isArray(params?.messages)) {
         span.setAttribute(STRUCT.INPUT_MESSAGE_COUNT, params.messages.length);
-        propagateUserPromptToParent(params.messages);
+        // Parent-prompt preview is CONTENT — never emit it in ContentCaptureMode.None.
+        // Deliberately kept in EventOnly (the default): shipped behavior in both
+        // SDKs and what the waterfall UI reads.
+        if (sdk.captureContent) {
+            sharedPropagateUserPromptToParent(lastUserMessageParts(params.messages));
+        }
     }
     if (sdk.emitEvents && logger && Array.isArray(params?.messages)) {
-        emitAnthropicMessageEvents(logger, params.messages, params.system);
+        emitAnthropicMessageEvents(logger, params.messages, params.system, span, provider);
     }
     if (sdk.emitSpanContent) {
         if (Array.isArray(params?.messages)) {
@@ -280,7 +707,7 @@ function setChatRequestAttrs(span, params, sdk, logger) {
         }
     }
 }
-function setChatResponseAttrs(span, sdk, response, logger) {
+function setChatResponseAttrs(span, sdk, response, logger, provider = "anthropic") {
     const usage = response.usage;
     if (usage) {
         const inputTokens = usage.input_tokens ?? 0;
@@ -310,7 +737,7 @@ function setChatResponseAttrs(span, sdk, response, logger) {
         // Always runs — populates pending queue regardless of content-capture mode.
         recordPendingToolCalls(response.content);
         if (sdk.emitEvents && logger) {
-            emitAnthropicChoiceEvent(logger, response.content, response.stop_reason);
+            emitAnthropicChoiceEvent(logger, response.content, response.stop_reason, span, provider);
         }
         if (sdk.emitSpanContent) {
             span.setAttribute(GEN_AI.OUTPUT_MESSAGES, toOutputMessages(response.content, response.stop_reason));
@@ -326,26 +753,6 @@ function recordPendingToolCalls(contentBlocks) {
     ensurePendingToolCallsSlot();
     pushPendingToolCalls(pairs);
 }
-function propagateUserPromptToParent(messages) {
-    try {
-        const agentSpan = getAgentSpan();
-        if (!agentSpan)
-            return;
-        // The SDK span type doesn't expose `attributes` — we use a brand check on
-        // the SDK's ReadableSpan-like shape.
-        const agentAttrs = agentSpan
-            .attributes;
-        if (agentAttrs && agentAttrs[GEN_AI.INPUT_MESSAGES])
-            return;
-        const parts = lastUserMessageParts(messages);
-        if (!parts)
-            return;
-        agentSpan.setAttribute(GEN_AI.INPUT_MESSAGES, truncateAndSerialize([{ role: "user", parts }]));
-    }
-    catch {
-        /* never fail the application for telemetry */
-    }
-}
 function recordErrorOnSpan(span, err) {
     const errorType = err instanceof Error ? err.constructor.name : typeof err;
     const message = err instanceof Error ? err.message : String(err);