@struct-ai/sdk 0.3.17 → 0.4.2

package/dist/commonjs/integrations/anthropic.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports._setChatRequestAttrsForTest = exports._detectProviderForTest = void 0;
 exports.patch = patch;
 exports.unpatch = unpatch;
 exports.wrapCreate = wrapCreate;
@@ -16,9 +17,11 @@ function childParentContext() {
         : api_1.context.active();
 }
 const core_js_1 = require("../core.js");
+const genai_content_js_1 = require("../genai-content.js");
 const events_js_1 = require("../events.js");
+const genai_content_js_2 = require("../genai-content.js");
+const instrument_js_1 = require("../instrument.js");
 const semconv_js_1 = require("../semconv.js");
-const truncation_js_1 = require("../truncation.js");
 const anthropic_content_js_1 = require("./anthropic-content.js");
 const STRUCT_WRAPPED = Symbol.for("struct.wrapped");
 const STRUCT_ORIGINAL = Symbol.for("struct.original");
@@ -106,113 +109,96 @@ 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 (0, genai_content_js_1.detectProviderFromResource)(resource, CLASS_NAME_RULES, HOST_RULES, "anthropic");
+}
+/** @internal */
+exports._detectProviderForTest = detectProvider;
+/** @internal */
+const _setChatRequestAttrsForTest = (span, params, sdk, logger, provider) => setChatRequestAttrs(span, params, sdk, logger, provider);
+exports._setChatRequestAttrsForTest = _setChatRequestAttrsForTest;
 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);
+        (0, context_js_1.propagateProviderToParent)(provider);
         if ((0, context_js_1.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;
-        (0, core_js_1.safe)(() => {
-            const parentCtx = childParentContext();
-            span = tracer.startSpan(`chat ${model}`, { kind: api_1.SpanKind.CLIENT }, parentCtx);
-            ctx = api_1.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 api_1.context.with(liveCtx, () => {
-            (0, core_js_1.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.
-                (0, core_js_1.safe)(() => recordErrorOnSpan(liveSpan, err), "anthropic.create.record_error", internalLogger);
-                (0, core_js_1.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) => {
-                        (0, core_js_1.safe)(() => setChatResponseAttrs(liveSpan, sdk, result, logger), "anthropic.create.set_response_attrs", internalLogger);
-                        (0, core_js_1.safe)(() => liveSpan.setStatus({ code: api_1.SpanStatusCode.OK }), "anthropic.create.set_ok_status", internalLogger);
-                        (0, core_js_1.safe)(() => liveSpan.end(), "anthropic.create.span_end", internalLogger);
-                    }, (err) => {
-                        (0, core_js_1.safe)(() => recordErrorOnSpan(liveSpan, err), "anthropic.create.record_error", internalLogger);
-                        (0, core_js_1.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.
-                (0, core_js_1.safe)(() => liveSpan.setStatus({ code: api_1.SpanStatusCode.OK }), "anthropic.create.set_ok_status", internalLogger);
-                (0, core_js_1.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.
-            (0, core_js_1.safe)(() => setChatResponseAttrs(liveSpan, sdk, rawResult, logger), "anthropic.create.set_response_attrs", internalLogger);
-            (0, core_js_1.safe)(() => liveSpan.setStatus({ code: api_1.SpanStatusCode.OK }), "anthropic.create.set_ok_status", internalLogger);
-            (0, core_js_1.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 (0, instrument_js_1.instrumentCall)(() => original.call(this, params, opts), {
+            tracer,
+            spanName: `chat ${model}`,
+            spanKind: api_1.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),
         });
     };
 }
@@ -222,13 +208,26 @@ 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);
+        (0, context_js_1.propagateProviderToParent)(streamProvider);
         if ((0, context_js_1.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.
@@ -255,7 +254,7 @@ function wrapStream(original) {
                     (0, core_js_1.safe)(() => recordErrorOnSpan(liveSpan, err), "anthropic.stream.record_error", internalLogger);
                 }
                 else if (result) {
-                    (0, core_js_1.safe)(() => api_1.context.with(liveCtx, () => setChatResponseAttrs(liveSpan, sdk, result, logger)), "anthropic.stream.set_response_attrs", internalLogger);
+                    (0, core_js_1.safe)(() => api_1.context.with(liveCtx, () => setChatResponseAttrs(liveSpan, sdk, result, logger, streamProvider)), "anthropic.stream.set_response_attrs", internalLogger);
                     (0, core_js_1.safe)(() => liveSpan.setStatus({ code: api_1.SpanStatusCode.OK }), "anthropic.stream.set_ok_status", internalLogger);
                 }
                 else {
@@ -294,10 +293,14 @@ function wrapStream(original) {
         // runs with a clean (unsuppressed) ALS store.
         let stream;
         try {
-            stream = api_1.context.with(liveCtx, () => {
-                (0, core_js_1.safe)(() => setChatRequestAttrs(liveSpan, params, sdk, logger), "anthropic.stream.set_request_attrs", internalLogger);
-                return (0, context_js_1.runWithContext)({ suppressGenAi: true }, () => original.call(this, params, opts));
-            });
+            (0, core_js_1.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 = (0, context_js_1.runWithContext)({ suppressGenAi: true }, () => original.call(this, params, opts));
         }
         catch (err) {
             // Sync throw from the original call would otherwise leak the span —
@@ -667,9 +670,9 @@ function wrapStream(original) {
         }
     };
 }
-function setChatRequestAttrs(span, params, sdk, logger) {
+function setChatRequestAttrs(span, params, sdk, logger, provider = "anthropic") {
     span.setAttribute(semconv_js_1.GEN_AI.OPERATION_NAME, "chat");
-    span.setAttribute(semconv_js_1.GEN_AI.PROVIDER_NAME, "anthropic");
+    span.setAttribute(semconv_js_1.GEN_AI.PROVIDER_NAME, provider);
     const model = params?.model ?? "unknown";
     span.setAttribute(semconv_js_1.GEN_AI.REQUEST_MODEL, model);
     const sessionId = (0, context_js_1.getSessionId)();
@@ -693,10 +696,15 @@ function setChatRequestAttrs(span, params, sdk, logger) {
     }
     if (Array.isArray(params?.messages)) {
         span.setAttribute(semconv_js_1.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) {
+            (0, genai_content_js_2.propagateUserPromptToParent)((0, anthropic_content_js_1.lastUserMessageParts)(params.messages));
+        }
     }
     if (sdk.emitEvents && logger && Array.isArray(params?.messages)) {
-        (0, events_js_1.emitAnthropicMessageEvents)(logger, params.messages, params.system);
+        (0, events_js_1.emitAnthropicMessageEvents)(logger, params.messages, params.system, span, provider);
     }
     if (sdk.emitSpanContent) {
         if (Array.isArray(params?.messages)) {
@@ -710,7 +718,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;
@@ -740,7 +748,7 @@ function setChatResponseAttrs(span, sdk, response, logger) {
         // Always runs — populates pending queue regardless of content-capture mode.
         recordPendingToolCalls(response.content);
         if (sdk.emitEvents && logger) {
-            (0, events_js_1.emitAnthropicChoiceEvent)(logger, response.content, response.stop_reason);
+            (0, events_js_1.emitAnthropicChoiceEvent)(logger, response.content, response.stop_reason, span, provider);
         }
         if (sdk.emitSpanContent) {
             span.setAttribute(semconv_js_1.GEN_AI.OUTPUT_MESSAGES, (0, anthropic_content_js_1.toOutputMessages)(response.content, response.stop_reason));
@@ -756,26 +764,6 @@ function recordPendingToolCalls(contentBlocks) {
     (0, context_js_1.ensurePendingToolCallsSlot)();
     (0, context_js_1.pushPendingToolCalls)(pairs);
 }
-function propagateUserPromptToParent(messages) {
-    try {
-        const agentSpan = (0, context_js_1.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[semconv_js_1.GEN_AI.INPUT_MESSAGES])
-            return;
-        const parts = (0, anthropic_content_js_1.lastUserMessageParts)(messages);
-        if (!parts)
-            return;
-        agentSpan.setAttribute(semconv_js_1.GEN_AI.INPUT_MESSAGES, (0, truncation_js_1.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/commonjs/integrations/index.js

@@ -16,6 +16,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/commonjs/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

package/dist/commonjs/integrations/langchain-callback.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructCallbackHandler = void 0;
+exports._detectProviderFromSerializedForTest = exports.StructCallbackHandler = void 0;
 const node_crypto_1 = require("node:crypto");
 const api_1 = require("@opentelemetry/api");
 const context_js_1 = require("../context.js");
@@ -330,7 +330,9 @@ class StructCallbackHandler {
         const startedSpan = span;
         (0, core_js_1.safe)(() => {
             startedSpan.setAttribute(semconv_js_1.GEN_AI.OPERATION_NAME, "invoke_agent");
-            startedSpan.setAttribute(semconv_js_1.GEN_AI.PROVIDER_NAME, "langchain");
+            // gen_ai.provider.name is stamped later by the first chat run under
+            // this agent (write-once) — "langchain" is a framework, not a
+            // provider, and the real one isn't known at chain start.
             startedSpan.setAttribute(semconv_js_1.GEN_AI.AGENT_NAME, String(agentName));
             // Do NOT set gen_ai.agent.id from sessionId — that conflates agent
             // identity (spec: stable agent-definition id) with a per-invocation
@@ -423,6 +425,17 @@ class StructCallbackHandler {
         const parentCtx = parentSpan
             ? api_1.trace.setSpan(api_1.context.active(), parentSpan)
             : api_1.context.active();
+        // CLASS RULE: detection => propagation BEFORE any child-span telemetry —
+        // a throwing tracer or failing chat-span write must not leave the healthy
+        // ancestor agent provider-less. ("langchain" is the unknown-model
+        // fallback sentinel, never propagated.) Parity: python
+        // on_chat_model_start stamp_ancestor.
+        (0, core_js_1.safe)(() => {
+            const providerAncestor = this.inheritedAgentSpan(parentRunId);
+            if (providerAncestor && provider !== "langchain") {
+                (0, context_js_1.stampProviderOnce)(providerAncestor, provider);
+            }
+        }, "langchain.handleChatModelStart.stamp_provider", this.internalLogger);
         let span;
         (0, core_js_1.safe)(() => {
             span = this.tracer.startSpan(`chat ${model}`, { kind: api_1.SpanKind.CLIENT }, parentCtx);
@@ -574,7 +587,8 @@ class StructCallbackHandler {
         const queueOwnership = this.resolveQueueOwnership(parentRunId);
         (0, core_js_1.safe)(() => {
             startedSpan.setAttribute(semconv_js_1.GEN_AI.OPERATION_NAME, "execute_tool");
-            startedSpan.setAttribute(semconv_js_1.GEN_AI.PROVIDER_NAME, "langchain");
+            // No gen_ai.provider.name: the spec's execute_tool span does not
+            // define that attribute.
             startedSpan.setAttribute(semconv_js_1.GEN_AI.TOOL_NAME, String(toolName));
             // Tool call id from metadata (LangChain passes it there for ToolCall
             // inputs) or fallback to the pending queue populated by the LLM's
@@ -658,7 +672,18 @@ class StructCallbackHandler {
                 span.setAttribute(semconv_js_1.GEN_AI.TOOL_CALL_RESULT, (0, truncation_js_1.safeJsonStringify)(output).slice(0, 8192));
             }
         }, "langchain.handleToolEnd.set_result", this.internalLogger);
-        (0, core_js_1.safe)(() => span.setStatus({ code: api_1.SpanStatusCode.OK }), "langchain.handleToolEnd.set_status", this.internalLogger);
+        (0, core_js_1.safe)(() => {
+            if (toolOutputSignalsError(output)) {
+                span.setAttribute(semconv_js_1.ERROR_TYPE, "tool_error");
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: "tool returned an error result",
+                });
+            }
+            else {
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+            }
+        }, "langchain.handleToolEnd.set_status", this.internalLogger);
         (0, core_js_1.safe)(() => span.end(), "langchain.handleToolEnd.span_end", this.internalLogger);
     };
     handleToolError = (err, runId) => {
@@ -691,7 +716,8 @@ class StructCallbackHandler {
         const sessionId = this.resolveSessionId(parentRunId, metadata);
         (0, core_js_1.safe)(() => {
             startedSpan.setAttribute(semconv_js_1.GEN_AI.OPERATION_NAME, "retrieval");
-            startedSpan.setAttribute(semconv_js_1.GEN_AI.PROVIDER_NAME, "langchain");
+            // No gen_ai.provider.name: not an inference span, and "langchain"
+            // isn't a provider.
             startedSpan.setAttribute(semconv_js_1.GEN_AI.DATA_SOURCE_ID, String(name));
             if (sessionId)
                 startedSpan.setAttribute(semconv_js_1.GEN_AI.CONVERSATION_ID, sessionId);
@@ -910,6 +936,11 @@ class StructCallbackHandler {
     }
     propagateUserPrompt(parentSpan, messages) {
         try {
+            // Parent-prompt preview is CONTENT — never emit it in ContentCaptureMode
+            // .None (same gate as the anthropic/openai provider paths; kept in
+            // EventOnly deliberately: shipped behavior the waterfall UI reads).
+            if (!this.sdk.captureContent)
+                return;
             const attrs = parentSpan
                 .attributes;
             if (attrs && attrs[semconv_js_1.GEN_AI.INPUT_MESSAGES])
@@ -1116,8 +1147,30 @@ function extractClassName(obj) {
 function detectProviderFromSerialized(llm) {
     const cls = extractClassName(llm) ?? "";
     const fake = { constructor: { name: cls }, _llmType: undefined };
-    return (0, langchain_content_js_1.detectProvider)(fake);
+    const byClass = (0, langchain_content_js_1.detectProvider)(fake);
+    if (byClass !== "langchain")
+        return byClass;
+    // Module-path fallback (parity with python's _detect_provider_from_serialized):
+    // an unknown/wrapped class under a known provider module (e.g.
+    // langchain_openai) still resolves to the real provider.
+    const ids = llm.id;
+    const modulePath = Array.isArray(ids) && typeof ids[0] === "string" ? ids[0] : "";
+    // SEGMENT-exact matching, scoped to langchain partner packages — substring
+    // classified lookalikes (langchain_notopenai -> openai), and the value gets
+    // write-once stamped onto agent spans, so a false positive is sticky.
+    if (modulePath === "langchain" ||
+        modulePath.startsWith("langchain_") ||
+        modulePath.startsWith("langchain.")) {
+        const segments = modulePath.split(/[._]/).filter(Boolean);
+        for (const [key, provider] of Object.entries(langchain_content_js_1.MODULE_PROVIDER_MAP)) {
+            if (segments.includes(key))
+                return provider;
+        }
+    }
+    return "langchain";
 }
+/** @internal */
+exports._detectProviderFromSerializedForTest = detectProviderFromSerialized;
 function extractParam(obj, key) {
     if (!obj || typeof obj !== "object")
         return undefined;
@@ -1344,4 +1397,29 @@ function recordError(span, err) {
     if (err instanceof Error)
         span.recordException(err);
 }
+/**
+ * Whether a LangChain tool OUTPUT signals in-band failure: a
+ * ToolMessage with status "error", or an MCP-style isError/is_error
+ * boolean-true flag on the top-level object. Mirrors python
+ * langchain.on_tool_end semantics — keep in lockstep.
+ */
+function toolOutputSignalsError(output) {
+    if (typeof output !== "object" || output === null)
+        return false;
+    // Per-key probe isolation: a hostile getter on one key must not mask a
+    // readable sibling. Mirrors python _tool_output_signals_error.
+    return (probe(output, "status") === "error" ||
+        probe(output, "isError") === true ||
+        probe(output, "is_error") === true);
+}
+/** Isolated single-property read of untrusted host data (see core.ts
+ * safeProbe — duplicated here because it is module-private there). */
+function probe(obj, key) {
+    try {
+        return obj[key];
+    }
+    catch {
+        return undefined;
+    }
+}
 //# sourceMappingURL=langchain-callback.js.map

package/dist/commonjs/integrations/langchain-content.js

@@ -15,7 +15,7 @@ const truncation_js_1 = require("../truncation.js");
 const semconv_js_1 = require("../semconv.js");
 exports.PROVIDER_MAP = {
     ChatOpenAI: "openai",
-    AzureChatOpenAI: "azure.openai",
+    AzureChatOpenAI: "azure.ai.openai",
     ChatAnthropic: "anthropic",
     ChatGoogleGenerativeAI: "gcp.generative_ai",
     ChatVertexAI: "gcp.vertex_ai",

package/dist/commonjs/integrations/openai-content.d.ts

@@ -0,0 +1,34 @@
+import type { Part } from "../genai-content.js";
+/** Map a Responses `message.content` (string or list) to spec parts. */
+export declare function messageContentToParts(content: unknown): Part[];
+/** Map ONE Responses `input` item to `[eventName, role, parts]`, or null. */
+export declare function inputItemToEvent(item: unknown): [string, string, Part[]] | null;
+/** Map ONE `response.output` item to the assistant's choice parts. */
+export declare function outputItemToChoiceParts(item: unknown): Part[];
+/** Normalize the `input` kwarg to a list of items (bare string → one user message). */
+export declare function normalizeInput(input: unknown): unknown[];
+/** Spec parts of the LAST `user` message in `input` (for parent propagation). */
+export declare function lastUserParts(input: unknown): Part[] | undefined;
+/** Every function_call `(name, call_id)` from a response.output (for tool linkage). */
+export declare function iterFunctionCalls(output: unknown): Array<[string, string]>;
+/** Derive a raw finish-reason string from a Responses response. */
+export declare function deriveFinishReason(response: unknown): string | undefined;
+/**
+ * True when a Responses response is in a terminal state (generation finished).
+ * A `background: true` request can return non-terminal (`"queued"` /
+ * `"in_progress"`) with no assistant message yet — we must NOT emit a terminal
+ * `gen_ai.choice` / finish reason for those. A response with no status is
+ * treated as terminal so we never silently drop telemetry for the common
+ * synchronous call (or minimal mocks).
+ */
+export declare function isTerminalResponse(response: unknown): boolean;
+/** Map a raw Responses status/derived reason to a spec choice finish reason. */
+export declare function mapChoiceFinishReason(raw: string | undefined): string;
+/** Serialize `input` → spec `gen_ai.input.messages` JSON string. */
+export declare function toInputMessages(input: unknown): string;
+/** Serialize Responses `instructions` → spec `system_instructions` JSON string. */
+export declare function toSystemInstructions(instructions: unknown): string;
+/** Serialize `response.output` → spec `gen_ai.output.messages` JSON string. */
+export declare function toOutputMessages(output: unknown, finishReason: string | undefined): string;
+export declare function safeJsonForTool(obj: unknown): string;
+//# sourceMappingURL=openai-content.d.ts.map