@struct-ai/sdk 0.3.0 → 0.4.2

package/dist/esm/events.js

@@ -1,37 +1,13 @@
-import { context as otelContext } from "@opentelemetry/api";
-import { SeverityNumber, } from "@opentelemetry/api-logs";
-import { getSessionId } from "./context.js";
-import { ANTHROPIC_FINISH_REASON_MAP, EVENT_NAME, EVENT_NAMES, GEN_AI, ROLE_TO_EVENT_NAME, } from "./semconv.js";
-import { safeJsonStringify, truncateParts } from "./truncation.js";
-import { contentToParts, } from "./integrations/anthropic-content.js";
-/**
- * Emit a LogRecord with the active span context linked.
- *
- * Follows the OTel logs data model convention:
- * - `body` (log record body) = event tag string (human-readable signal)
- * - `attributes.body` (log record attribute) = JSON-serialised payload
- */
-function emitLogRecord({ logger, eventName, payload, extraAttrs = {}, }) {
-    const sessionId = getSessionId();
-    const attributes = {
-        [EVENT_NAME]: eventName,
-        body: payload,
-        ...extraAttrs,
-    };
-    if (sessionId)
-        attributes[GEN_AI.CONVERSATION_ID] = sessionId;
-    logger.emit({
-        body: eventName,
-        severityNumber: SeverityNumber.INFO,
-        attributes,
-        context: otelContext.active(),
-    });
-}
+import { emitChoiceEvent, emitMessageEvent, } from "./genai-content.js";
+import { ANTHROPIC_FINISH_REASON_MAP, EVENT_NAMES, ROLE_TO_EVENT_NAME, } from "./semconv.js";
+import { contentToParts } from "./integrations/anthropic-content.js";
+import { inputItemToEvent, mapChoiceFinishReason, normalizeInput, outputItemToChoiceParts, } from "./integrations/openai-content.js";
 /**
  * Emit per-message log events for an Anthropic messages.create() call.
- * Port of _emit_message_events from anthropic.py.
+ * Delegates the LogRecord wiring to the shared genai-content emitters; this
+ * function is only the Anthropic message → parts mapping + ordering.
  */
-export function emitAnthropicMessageEvents(logger, messages, system) {
+export function emitAnthropicMessageEvents(logger, messages, system, span, provider = "anthropic") {
     if (!Array.isArray(messages))
         return;
     let msgIndex = 0;
@@ -41,17 +17,14 @@ export function emitAnthropicMessageEvents(logger, messages, system) {
             : Array.isArray(system)
                 ? contentToParts(system)
                 : [{ type: "text", content: String(system) }];
-        emitLogRecord({
+        emitMessageEvent({
             logger,
+            role: "system",
+            parts,
             eventName: EVENT_NAMES.SYSTEM_MESSAGE,
-            payload: safeJsonStringify({
-                role: "system",
-                parts: truncateParts(parts),
-            }),
-            extraAttrs: {
-                [GEN_AI.SYSTEM]: "anthropic",
-                [GEN_AI.MESSAGE_INDEX]: msgIndex,
-            },
+            provider,
+            messageIndex: msgIndex,
+            span,
         });
         msgIndex++;
     }
@@ -62,38 +35,86 @@ export function emitAnthropicMessageEvents(logger, messages, system) {
         const role = typeof m.role === "string" ? m.role : "user";
         const parts = contentToParts(m.content);
         const eventName = ROLE_TO_EVENT_NAME[role] ?? `gen_ai.${role}.message`;
-        emitLogRecord({
+        emitMessageEvent({
             logger,
+            role,
+            parts,
             eventName,
-            payload: safeJsonStringify({ role, parts: truncateParts(parts) }),
-            extraAttrs: {
-                [GEN_AI.SYSTEM]: "anthropic",
-                [GEN_AI.MESSAGE_INDEX]: msgIndex,
-            },
+            provider,
+            messageIndex: msgIndex,
+            span,
         });
         msgIndex++;
     }
 }
-/**
- * Emit a gen_ai.choice LogRecord for an Anthropic response.
- * Port of _emit_choice_event from anthropic.py.
- */
-export function emitAnthropicChoiceEvent(logger, contentBlocks, stopReason) {
+/** Emit a gen_ai.choice LogRecord for an Anthropic response. */
+export function emitAnthropicChoiceEvent(logger, contentBlocks, stopReason, span, provider = "anthropic") {
     const parts = contentToParts(contentBlocks);
     const mappedReason = (stopReason && (ANTHROPIC_FINISH_REASON_MAP[stopReason] ?? stopReason)) ||
         "stop";
-    const payload = safeJsonStringify({
-        index: 0,
-        finish_reason: mappedReason,
-        message: { role: "assistant", parts: truncateParts(parts) },
+    emitChoiceEvent({
+        logger,
+        parts,
+        finishReason: mappedReason,
+        provider,
+        span,
     });
-    emitLogRecord({
+}
+/**
+ * Emit per-message log events for an OpenAI responses.create() call.
+ * `instructions` (the Responses system prompt) is emitted FIRST at index 0.
+ * Delegates LogRecord wiring to the shared emitters; only the Responses
+ * item → event mapping + ordering lives here.
+ */
+export function emitOpenAIInputMessageEvents(logger, input, instructions, span, provider = "openai") {
+    let msgIndex = 0;
+    if (instructions) {
+        const parts = typeof instructions === "string"
+            ? [{ type: "text", content: instructions }]
+            : [{ type: "text", content: String(instructions) }];
+        emitMessageEvent({
+            logger,
+            role: "system",
+            parts,
+            eventName: EVENT_NAMES.SYSTEM_MESSAGE,
+            provider,
+            messageIndex: msgIndex,
+            span,
+        });
+        msgIndex++;
+    }
+    for (const item of normalizeInput(input)) {
+        const mapped = inputItemToEvent(item);
+        if (!mapped)
+            continue;
+        const [eventName, role, parts] = mapped;
+        emitMessageEvent({
+            logger,
+            role,
+            parts,
+            eventName,
+            provider,
+            messageIndex: msgIndex,
+            span,
+        });
+        msgIndex++;
+    }
+}
+/**
+ * Emit the gen_ai.choice LogRecord from an OpenAI response.output.
+ * `finishReason` is mapped inside this emitter using mapChoiceFinishReason.
+ */
+export function emitOpenAIChoiceEvent(logger, output, finishReason, span, provider = "openai") {
+    const parts = [];
+    for (const item of Array.isArray(output) ? output : []) {
+        parts.push(...outputItemToChoiceParts(item));
+    }
+    emitChoiceEvent({
         logger,
-        eventName: EVENT_NAMES.CHOICE,
-        payload,
-        extraAttrs: {
-            [GEN_AI.SYSTEM]: "anthropic",
-        },
+        parts,
+        finishReason: mapChoiceFinishReason(finishReason),
+        provider,
+        span,
     });
 }
 //# sourceMappingURL=events.js.map

package/dist/esm/genai-content.d.ts

@@ -0,0 +1,52 @@
+import { type Span } from "@opentelemetry/api";
+import { type Logger } from "@opentelemetry/api-logs";
+/** Part in the GenAI spec format (provider-agnostic, already mapped). */
+export type Part = Record<string, unknown>;
+/** Emit ONE per-message LogRecord from already-built spec parts. */
+export declare function emitMessageEvent(opts: {
+    logger: Logger;
+    role: string;
+    parts: Part[];
+    eventName: string;
+    provider: string;
+    messageIndex: number;
+    span?: Span;
+}): void;
+/**
+ * Emit the `gen_ai.choice` LogRecord. `finishReason` is already spec-mapped by
+ * the caller (mapping is provider-specific). Omits `gen_ai.message.index`.
+ */
+export declare function emitChoiceEvent(opts: {
+    logger: Logger;
+    parts: Part[];
+    finishReason: string;
+    provider: string;
+    span?: Span;
+}): void;
+/**
+ * Stamp the last user message on the parent invoke_agent span (write-once).
+ * Provider-agnostic: the caller extracts the last user message's spec parts
+ * (Anthropic message blocks vs Responses items differ); this only stamps them.
+ */
+export declare function propagateUserPromptToParent(lastUserParts: Part[] | undefined): void;
+export type ProviderClassNameRule = readonly [ReadonlySet<string>, string];
+export type ProviderHostRule = readonly [(host: string) => boolean, string];
+/**
+ * Best-knowledge `gen_ai.provider.name` from a bound resource. TS twin of
+ * python `_genai_content.detect_provider_from_resource`.
+ *
+ * The platform client flavors (@anthropic-ai/bedrock-sdk, /vertex-sdk,
+ * AzureOpenAI) reuse the same resource prototypes as the first-party clients,
+ * so the platform is read at call time from the resource's owning client:
+ * EXACT constructor names up the prototype chain first (exact, not substring
+ * — a class named `NotAzureOpenAI` must not match; subclasses match via their
+ * inherited base's name), then per-platform `baseURL` host predicates matching
+ * only official endpoint shapes.
+ *
+ * Takes the RESOURCE: the `_client` property access is a host-boundary read (a
+ * proxied resource can throw from its getter), so it happens inside this
+ * function's guard. Falls back whenever routing is not positively detectable;
+ * never throws.
+ */
+export declare function detectProviderFromResource(resource: unknown, classNameRules: readonly ProviderClassNameRule[], hostRules: readonly ProviderHostRule[], fallback: string): string;
+//# sourceMappingURL=genai-content.d.ts.map

package/dist/esm/genai-content.js

@@ -0,0 +1,137 @@
+import { context as otelContext, trace } from "@opentelemetry/api";
+import { SeverityNumber, } from "@opentelemetry/api-logs";
+import { getAgentSpan, getSessionId } from "./context.js";
+import { EVENT_NAME, EVENT_NAMES, GEN_AI } from "./semconv.js";
+import { safeJsonStringify, truncateAndSerialize, truncateParts, } from "./truncation.js";
+/**
+ * Low-level LogRecord emitter — the single home for the OTel logs data-model
+ * wiring both providers share:
+ * - `body` (log record body) = event-tag string
+ * - `attributes.body` = JSON-serialised structured payload
+ * - `gen_ai.provider.name` always stamped; `gen_ai.conversation.id` when a
+ *   session is active.
+ *
+ * Span-context is taken from the EXPLICIT `span` when given. This matters on
+ * async resolution paths (provider `.then` continuations): OTel context does
+ * NOT auto-propagate there (the SDK installs no global context manager), so
+ * `otelContext.active()` would drop the chat span and mis-link the record.
+ * Passing the span explicitly pins the linkage. (ALS-derived values like the
+ * session id DO propagate via async_hooks, so `getSessionId()` stays correct.)
+ */
+function emitLogRecord(logger, eventName, payload, extraAttrs, span) {
+    const sessionId = getSessionId();
+    const attributes = {
+        [EVENT_NAME]: eventName,
+        body: payload,
+        ...extraAttrs,
+    };
+    if (sessionId)
+        attributes[GEN_AI.CONVERSATION_ID] = sessionId;
+    const ctx = span
+        ? trace.setSpan(otelContext.active(), span)
+        : otelContext.active();
+    logger.emit({
+        body: eventName,
+        severityNumber: SeverityNumber.INFO,
+        attributes,
+        context: ctx,
+    });
+}
+/** Emit ONE per-message LogRecord from already-built spec parts. */
+export function emitMessageEvent(opts) {
+    const { logger, role, parts, eventName, provider, messageIndex, span } = opts;
+    emitLogRecord(logger, eventName, safeJsonStringify({ role, parts: truncateParts(parts) }), {
+        [GEN_AI.PROVIDER_NAME]: provider,
+        [GEN_AI.MESSAGE_INDEX]: messageIndex,
+    }, span);
+}
+/**
+ * Emit the `gen_ai.choice` LogRecord. `finishReason` is already spec-mapped by
+ * the caller (mapping is provider-specific). Omits `gen_ai.message.index`.
+ */
+export function emitChoiceEvent(opts) {
+    const { logger, parts, finishReason, provider, span } = opts;
+    const payload = safeJsonStringify({
+        index: 0,
+        finish_reason: finishReason || "stop",
+        message: { role: "assistant", parts: truncateParts(parts) },
+    });
+    emitLogRecord(logger, EVENT_NAMES.CHOICE, payload, { [GEN_AI.PROVIDER_NAME]: provider }, span);
+}
+/**
+ * Stamp the last user message on the parent invoke_agent span (write-once).
+ * Provider-agnostic: the caller extracts the last user message's spec parts
+ * (Anthropic message blocks vs Responses items differ); this only stamps them.
+ */
+export function propagateUserPromptToParent(lastUserParts) {
+    try {
+        // Skip when the last user message has no parts (null/empty content). This
+        // matches Python's `_genai_content.propagate_user_prompt_to_parent`
+        // (`if not last_user_parts: return`) — an intentional parity-aligned delta
+        // from the old Anthropic-only helper, which stamped an empty stub here.
+        if (!lastUserParts || lastUserParts.length === 0)
+            return;
+        const agentSpan = getAgentSpan();
+        if (!agentSpan)
+            return;
+        // The SDK span type doesn't expose `attributes` — brand-check the
+        // ReadableSpan-like shape (same as the prior anthropic.ts inline helper).
+        const agentAttrs = agentSpan.attributes;
+        if (agentAttrs && agentAttrs[GEN_AI.INPUT_MESSAGES])
+            return; // write-once
+        agentSpan.setAttribute(GEN_AI.INPUT_MESSAGES, truncateAndSerialize([{ role: "user", parts: lastUserParts }]));
+    }
+    catch {
+        /* never fail the application for telemetry */
+    }
+}
+/**
+ * Best-knowledge `gen_ai.provider.name` from a bound resource. TS twin of
+ * python `_genai_content.detect_provider_from_resource`.
+ *
+ * The platform client flavors (@anthropic-ai/bedrock-sdk, /vertex-sdk,
+ * AzureOpenAI) reuse the same resource prototypes as the first-party clients,
+ * so the platform is read at call time from the resource's owning client:
+ * EXACT constructor names up the prototype chain first (exact, not substring
+ * — a class named `NotAzureOpenAI` must not match; subclasses match via their
+ * inherited base's name), then per-platform `baseURL` host predicates matching
+ * only official endpoint shapes.
+ *
+ * Takes the RESOURCE: the `_client` property access is a host-boundary read (a
+ * proxied resource can throw from its getter), so it happens inside this
+ * function's guard. Falls back whenever routing is not positively detectable;
+ * never throws.
+ */
+export function detectProviderFromResource(resource, classNameRules, hostRules, fallback) {
+    try {
+        const client = resource
+            ?._client;
+        if (!client || typeof client !== "object")
+            return fallback;
+        let proto = Object.getPrototypeOf(client);
+        while (proto) {
+            const name = proto.constructor
+                ?.name;
+            if (typeof name === "string") {
+                for (const [names, provider] of classNameRules) {
+                    if (names.has(name))
+                        return provider;
+                }
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        const raw = client.baseURL;
+        const host = raw ? new URL(String(raw)).hostname : "";
+        if (host) {
+            for (const [matchesHost, provider] of hostRules) {
+                if (matchesHost(host))
+                    return provider;
+            }
+        }
+    }
+    catch {
+        /* detection must never fault the host call */
+    }
+    return fallback;
+}
+//# sourceMappingURL=genai-content.js.map

package/dist/esm/instrument.d.ts

@@ -0,0 +1,47 @@
+import { SpanKind, type Context, type Span, type Tracer } from "@opentelemetry/api";
+import { type InternalLogger } from "./core.js";
+/**
+ * Telemetry callbacks + span config a provider supplies to {@link instrumentCall}.
+ * The callbacks are the ONLY provider-specific code; they run inside `safe()`
+ * and may never reach the host call path.
+ */
+export interface CallInstrumentation {
+    tracer: Tracer;
+    spanName: string;
+    spanKind: SpanKind;
+    /** Resolves the parent context for the span (e.g. the enclosing agent span). */
+    parentContext: () => Context;
+    /** Prefix for `safe()` telemetry-failure sites, e.g. `"openai.create"`. */
+    sitePrefix: string;
+    internalLogger: InternalLogger;
+    /** Set request-side attributes + emit request log events (given the span). */
+    onStart: (span: Span) => void;
+    /** Set response-side attributes + emit the choice event (given the span). */
+    onSuccess: (span: Span, result: unknown) => void;
+    /** Record an error on the span. */
+    onError: (span: Span, err: unknown) => void;
+}
+/**
+ * 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 declare function instrumentCall(invoke: () => unknown, inst: CallInstrumentation): unknown;
+//# sourceMappingURL=instrument.d.ts.map

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,13 @@ 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 */
 export type _PatchContextForTest = PatchContext;
 /** @internal */