@struct-ai/sdk 0.3.17 → 0.4.3

package/dist/esm/instrument.js

@@ -0,0 +1,155 @@
+import { SpanStatusCode, context as otelContext, trace, } from "@opentelemetry/api";
+import { runWithStore, snapshotStore } from "./context.js";
+import { safe } from "./core.js";
+/**
+ * The single audited host boundary for provider `create()` instrumentation.
+ *
+ * STRUCTURAL GUARANTEE: `invoke()` (the host provider call) runs EXACTLY ONCE,
+ * and its return value / thrown error reaches the caller UNCHANGED, regardless
+ * of any telemetry failure. Nothing host-controllable — a customer's global
+ * OTel `ContextManager`, a hostile response/thenable, a broken tracer — is ever
+ * on the synchronous path that produces `invoke()`'s result:
+ *
+ *   - span creation is `safe()`-guarded; on failure we run `invoke()`
+ *     uninstrumented and return it;
+ *   - all telemetry (request attrs/events, response attrs/events, error
+ *     recording, span end) runs in `safe()` satellites that degrade to
+ *     "no telemetry" on any throw;
+ *   - `invoke()` itself is NOT wrapped in `otelContext.with(...)` or any other
+ *     host-controllable operation — log-record→span linkage is carried by the
+ *     explicit span passed to the emitters, not by ambient context.
+ *
+ * New providers supply only the telemetry callbacks, so they add no new way to
+ * break the host. Mirrors struct-sdk-python's generator sandwich in
+ * `_create_common` / `_wrap_create`.
+ */
+export function instrumentCall(invoke, inst) {
+    const { tracer, spanName, spanKind, parentContext, sitePrefix, internalLogger } = inst;
+    let span;
+    let spanCtx;
+    safe(() => {
+        const parentCtx = parentContext();
+        span = tracer.startSpan(spanName, { kind: spanKind }, parentCtx);
+        spanCtx = trace.setSpan(parentCtx, span);
+    }, `${sitePrefix}.start_span`, internalLogger);
+    if (!span || !spanCtx) {
+        // Span creation failed partway (custom tracer / broken context manager /
+        // hostile Context.setValue). If the span WAS created before the failure,
+        // end it best-effort so it can't leak un-ended forever; then run the host
+        // call uninstrumented — never blocked by our telemetry.
+        const created = span;
+        if (created) {
+            safe(() => created.end(), `${sitePrefix}.span_end`, internalLogger);
+        }
+        return invoke();
+    }
+    const liveSpan = span;
+    const liveSpanCtx = spanCtx;
+    const storeSnapshot = snapshotStore();
+    safe(() => inst.onStart(liveSpan), `${sitePrefix}.set_request_attrs`, internalLogger);
+    // Run the host call with the chat span active in the ambient context, so a
+    // span the CUSTOMER's own tracer creates during the call (their HTTP/fetch
+    // instrumentation) nests under `chat` instead of becoming a sibling.
+    //
+    // GUARDED against a hostile global ContextManager: `otelContext.with` runs
+    // customer-controlled code that can misbehave in every direction — throw on
+    // context enter, throw on exit AFTER the callback ran, silently SKIP the
+    // callback, or call it MORE THAN ONCE. The `invoked` flag makes runInvoke
+    // idempotent (a double-calling manager can't duplicate the request) and the
+    // unconditional post-`with` check runs the call whenever the manager skipped
+    // it (silently or by throwing on enter). Exit-throw-after-call does NOT
+    // retry: `invoked` is already true. Net: the host call runs EXACTLY ONCE, no
+    // matter what the manager does.
+    let invoked = false;
+    let rawResult;
+    let threw = false;
+    let thrownErr;
+    const runInvoke = () => {
+        if (invoked)
+            return; // idempotent — hostile managers may call twice
+        invoked = true;
+        try {
+            rawResult = invoke();
+        }
+        catch (err) {
+            threw = true;
+            thrownErr = err;
+        }
+    };
+    try {
+        otelContext.with(liveSpanCtx, runInvoke);
+    }
+    catch {
+        /* enter/exit threw — the post-check below decides; never rethrow ours */
+    }
+    if (!invoked)
+        runInvoke(); // manager skipped the callback (silently or via throw)
+    if (threw) {
+        finalizeError(liveSpan, thrownErr, inst, storeSnapshot);
+        throw thrownErr; // the host's own error, unchanged
+    }
+    return observeResult(liveSpan, rawResult, inst, storeSnapshot);
+}
+function finalizeSuccess(span, result, inst, store) {
+    const { sitePrefix, internalLogger } = inst;
+    safe(() => runWithStore(store, () => {
+        safe(() => inst.onSuccess(span, result), `${sitePrefix}.set_response_attrs`, internalLogger);
+        safe(() => span.setStatus({ code: SpanStatusCode.OK }), `${sitePrefix}.set_ok_status`, internalLogger);
+        safe(() => span.end(), `${sitePrefix}.span_end`, internalLogger);
+    }), `${sitePrefix}.finalize`, internalLogger);
+}
+function finalizeError(span, err, inst, store) {
+    const { sitePrefix, internalLogger } = inst;
+    safe(() => runWithStore(store, () => {
+        safe(() => inst.onError(span, err), `${sitePrefix}.record_error`, internalLogger);
+        safe(() => span.end(), `${sitePrefix}.span_end_on_error`, internalLogger);
+    }), `${sitePrefix}.finalize_error`, internalLogger);
+}
+/**
+ * Observe the host call's return value for telemetry and hand it back UNCHANGED.
+ * A thenable (the provider's `APIPromise`) is observed via `.then(...)`, never
+ * replaced with a native `Promise` (which would strip `.withResponse()` etc.).
+ * The `.then` property read + registration are guarded so a hostile thenable
+ * degrades instead of throwing out of the (already-successful) host call.
+ */
+function observeResult(span, rawResult, inst, store) {
+    const { sitePrefix, internalLogger } = inst;
+    // Exactly-once settlement, shared by BOTH observer callbacks and the
+    // hostile-thenable catch path: a custom PromiseLike may invoke onFulfilled
+    // twice, or onFulfilled then onRejected, or run callbacks synchronously and
+    // THEN throw from `.then` — any of which would otherwise double-finalize
+    // (duplicate choice events, duplicate pending tool-call ids, repeated
+    // span.end). Same invariant as runInvoke's `invoked` flag, applied to the
+    // observation side.
+    let settled = false;
+    const settleOnce = (fn) => {
+        if (settled)
+            return;
+        settled = true;
+        fn();
+    };
+    try {
+        const rt = rawResult;
+        if (rt && typeof rt.then === "function") {
+            rawResult.then((result) => settleOnce(() => finalizeSuccess(span, result, inst, store)), 
+            // Observer branch only — does NOT rethrow; the original promise still
+            // rejects to the caller independently, so no unhandled rejection.
+            (err) => settleOnce(() => finalizeError(span, err, inst, store)));
+            return rawResult;
+        }
+    }
+    catch {
+        // Reading/invoking `.then` threw (hostile thenable). The host call already
+        // produced rawResult — degrade: close the span (unless a synchronously-run
+        // callback already settled it), hand rawResult back untouched.
+        settleOnce(() => {
+            safe(() => span.setStatus({ code: SpanStatusCode.OK }), `${sitePrefix}.set_ok_status`, internalLogger);
+            safe(() => span.end(), `${sitePrefix}.span_end`, internalLogger);
+        });
+        return rawResult;
+    }
+    // Non-thenable (a synchronous / mocked result): finalize inline.
+    settleOnce(() => finalizeSuccess(span, rawResult, inst, store));
+    return rawResult;
+}
+//# sourceMappingURL=instrument.js.map

package/dist/esm/integrations/anthropic-content.js

@@ -1,4 +1,4 @@
-import { safeJsonStringify, truncateAndSerialize, truncateField, } from "../truncation.js";
+import { serializeToolDefinitions, truncateAndSerialize, truncateField, } from "../truncation.js";
 import { ANTHROPIC_FINISH_REASON_MAP } from "../semconv.js";
 /**
  * Walk Anthropic response content blocks, return (name, id) pairs for tool_use blocks.
@@ -21,6 +21,21 @@ export function iterToolUses(blocks) {
     }
     return out;
 }
+/**
+ * Read a boolean flag defensively. A hostile getter/Proxy trap must not
+ * poison the whole message capture — toInputMessages replaces the ENTIRE
+ * payload with "[]" on an escape from contentToParts — so an unreadable
+ * flag is simply absent while the rest of the block survives. Mirrors
+ * python _flag_is_true in anthropic.py — keep in lockstep.
+ */
+function flagIsTrue(block, key) {
+    try {
+        return block[key] === true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Convert arbitrary content (string | block[] | unknown) → GenAI parts.
  * Port of _content_to_parts from anthropic.py.
@@ -64,6 +79,8 @@ export function contentToParts(content) {
             if (block.tool_use_id)
                 part.id = block.tool_use_id;
             part.response = block.content ?? "";
+            if (flagIsTrue(block, "is_error"))
+                part.is_error = true;
             parts.push(part);
         }
         else if (blockType === "thinking") {
@@ -145,12 +162,7 @@ export function toSystemInstructions(system) {
     }
 }
 export function safeJsonForTool(obj) {
-    try {
-        return truncateAndSerialize(obj);
-    }
-    catch {
-        return safeJsonStringify(obj);
-    }
+    return serializeToolDefinitions(obj);
 }
 /** Extract the last user message's parts for parent-span propagation. */
 export function lastUserMessageParts(messages) {

package/dist/esm/integrations/anthropic.d.ts

@@ -1,4 +1,4 @@
-import { type Tracer } from "@opentelemetry/api";
+import { type Span, type Tracer } from "@opentelemetry/api";
 import type { Logger } from "@opentelemetry/api-logs";
 import { type StructSDK } from "../core.js";
 interface PatchContext {
@@ -22,6 +22,11 @@ export declare function patch(sdk: StructSDK): Promise<void>;
 export declare function unpatch(): Promise<void>;
 type CreateMethod = (this: unknown, params: CreateParams, opts?: unknown) => unknown;
 type StreamMethod = (this: unknown, params: CreateParams, opts?: unknown) => unknown;
+declare function detectProvider(resource: unknown): string;
+/** @internal */
+export declare const _detectProviderForTest: typeof detectProvider;
+/** @internal */
+export declare const _setChatRequestAttrsForTest: (span: Span, params: CreateParams | undefined, sdk: StructSDK, logger: Logger | undefined, provider?: string) => void;
 export declare function wrapCreate(original: CreateMethod): CreateMethod;
 export declare function wrapStream(original: StreamMethod): StreamMethod;
 /** @internal */

package/dist/esm/integrations/anthropic.js

@@ -1,5 +1,5 @@
 import { SpanKind, SpanStatusCode, context as otelContext, trace, } from "@opentelemetry/api";
-import { ensurePendingToolCallsSlot, getAgentSpan, getSessionId, isGenAiSuppressed, pushPendingToolCalls, runWithContext, 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,113 +99,95 @@ function restoreMethod(proto, methodName) {
         proto[methodName] = current[STRUCT_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);
-            let rawResult;
-            try {
-                rawResult = original.call(this, params, opts);
-            }
-            catch (err) {
-                // Sync throw from the original call (e.g. a validation error thrown
-                // before any request goes out) would otherwise leak the span — no
-                // promise is ever created to drive the .then/.catch below.
-                safe(() => recordErrorOnSpan(liveSpan, err), "anthropic.create.record_error", internalLogger);
-                safe(() => liveSpan.end(), "anthropic.create.span_end_on_error", internalLogger);
-                throw err;
-            }
-            // Observe the SDK's own return value (Anthropic's APIPromise) for
-            // telemetry, then hand it BACK UNCHANGED — replacing it with a native
-            // `Promise.resolve(...).then(...)` strips APIPromise methods
-            // (.withResponse/.asResponse), breaking customer code only when
-            // instrumentation is enabled. Our observer chain must not create an
-            // unhandled rejection. (The prior code returned a native Promise here;
-            // this is adjacent hardening of pre-existing behavior — the identity
-            // hazard predates the streaming work.)
-            //
-            // Both the `.then` PROPERTY READ (`rt.then`) and the `.then(...)` CALL
-            // that registers our observer run SYNCHRONOUSLY on the success path of
-            // a customer's `create()` call, and were previously unguarded — a
-            // hostile thenable (a `.then` accessor that throws on read, or a
-            // `.then` function that throws synchronously when invoked) would turn
-            // a SUCCESSFUL Anthropic request into a synchronous exception thrown
-            // out of `wrappedCreate`. Wrap the read + registration so a broken
-            // thenable degrades instead of crashing the host: close the span with
-            // no telemetry and hand back rawResult UNCHANGED — never
-            // `Promise.resolve(...)`, which would also strip APIPromise
-            // identity/methods.
-            try {
-                const rt = rawResult;
-                if (rt && typeof rt.then === "function") {
-                    rawResult.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);
-                    }, (err) => {
-                        safe(() => recordErrorOnSpan(liveSpan, err), "anthropic.create.record_error", internalLogger);
-                        safe(() => liveSpan.end(), "anthropic.create.span_end_on_error", internalLogger);
-                        // Observer branch only — do NOT rethrow; the original APIPromise
-                        // still rejects to the customer independently.
-                    });
-                    return rawResult;
-                }
-            }
-            catch {
-                // Reading `.then` or invoking it threw (hostile thenable). The
-                // underlying call already succeeded (rawResult exists) — this is an
-                // instrumentation-only failure, not an API error. Degrade like the
-                // other host-crash guards in this file (e.g. wrapStream's dispatch
-                // region below): close the span with no telemetry, hand back
-                // rawResult untouched.
-                safe(() => liveSpan.setStatus({ code: SpanStatusCode.OK }), "anthropic.create.set_ok_status", internalLogger);
-                safe(() => liveSpan.end(), "anthropic.create.span_end", internalLogger);
-                return rawResult;
-            }
-            // Non-thenable return (a synchronous / mocked result, or any SDK shape
-            // that isn't a promise): run the response telemetry inline on it, close
-            // the span, and hand it back untouched — matching the prior
-            // `Promise.resolve(...).then(...)` behavior, which unified thenable and
-            // non-thenable returns.
-            safe(() => setChatResponseAttrs(liveSpan, sdk, rawResult, 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 rawResult;
+        // 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),
         });
     };
 }
@@ -213,13 +197,26 @@ export function wrapStream(original) {
         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.
@@ -246,7 +243,7 @@ export 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 {
@@ -285,10 +282,14 @@ export function wrapStream(original) {
         // runs with a clean (unsuppressed) ALS store.
         let stream;
         try {
-            stream = otelContext.with(liveCtx, () => {
-                safe(() => setChatRequestAttrs(liveSpan, params, sdk, logger), "anthropic.stream.set_request_attrs", internalLogger);
-                return runWithContext({ suppressGenAi: true }, () => original.call(this, params, opts));
-            });
+            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 —
@@ -658,9 +659,9 @@ export function wrapStream(original) {
         }
     };
 }
-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();
@@ -684,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)) {
@@ -701,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;
@@ -731,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));
@@ -747,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);

package/dist/esm/integrations/index.js

@@ -11,6 +11,14 @@ const INTEGRATIONS = [
             await mod.patch(sdk);
         },
     },
+    {
+        name: "openai",
+        probe: () => import("openai"),
+        apply: async (sdk) => {
+            const mod = await import("./openai.js");
+            await mod.patch(sdk);
+        },
+    },
     {
         name: "langchain",
         probe: () => import("@langchain/core/language_models/chat_models"),

package/dist/esm/integrations/langchain-callback.d.ts

@@ -282,5 +282,8 @@ export declare class StructCallbackHandler {
     private resolveAgentSessionId;
     private propagateUserPrompt;
 }
+declare function detectProviderFromSerialized(llm: Serialized): string;
+/** @internal */
+export declare const _detectProviderFromSerializedForTest: typeof detectProviderFromSerialized;
 export {};
 //# sourceMappingURL=langchain-callback.d.ts.map