@struct-ai/sdk 0.3.0 → 0.4.2

package/dist/commonjs/core.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StructSDK = exports.firstFailureLogged = exports.DEFAULT_ENDPOINT = void 0;
 exports.safe = safe;
-const node_crypto_1 = require("node:crypto");
 const api_1 = require("@opentelemetry/api");
 const exporter_logs_otlp_proto_1 = require("@opentelemetry/exporter-logs-otlp-proto");
 const exporter_trace_otlp_proto_1 = require("@opentelemetry/exporter-trace-otlp-proto");
@@ -14,6 +13,7 @@ const context_js_1 = require("./context.js");
 const index_js_1 = require("./integrations/index.js");
 const semconv_js_1 = require("./semconv.js");
 const truncation_js_1 = require("./truncation.js");
+const version_js_1 = require("./version.js");
 exports.DEFAULT_ENDPOINT = "https://ingest.struct.ai";
 const LOG_ENABLED = process.env.STRUCT_SDK_LOG === "1";
 const defaultInternalLogger = {
@@ -88,12 +88,22 @@ function safe(fn, site, logger) {
         fn();
     }
     catch (err) {
-        if (exports.firstFailureLogged.has(site)) {
-            logger.debug(`Struct SDK suppressed exception at ${site}`, err);
+        // The diagnostic log MUST NOT itself throw into the host: the default
+        // logger reaches `console.warn`, which a host may have replaced with a
+        // throwing implementation, and callers pass custom loggers. A throw here
+        // would escape `safe()` and defeat its whole purpose (e.g. block the host
+        // call when span creation fails). Guard the logging too.
+        try {
+            if (exports.firstFailureLogged.has(site)) {
+                logger.debug(`Struct SDK suppressed exception at ${site}`, err);
+            }
+            else {
+                exports.firstFailureLogged.add(site);
+                logger.warn(`Struct SDK suppressed exception at ${site}`, err);
+            }
         }
-        else {
-            exports.firstFailureLogged.add(site);
-            logger.warn(`Struct SDK suppressed exception at ${site}`, err);
+        catch {
+            /* diagnostic logging failed — never propagate into the host path */
         }
     }
 }
@@ -232,13 +242,13 @@ class StructSDK {
         if (!this._tracerProvider) {
             throw new Error("Call struct.init() before using the SDK");
         }
-        return this._tracerProvider.getTracer(name);
+        return this._tracerProvider.getTracer(name, version_js_1.SDK_VERSION);
     }
     getLogger(name = "struct-sdk") {
         if (!this._loggerProvider) {
             throw new Error("Call struct.init() before using the SDK");
         }
-        return this._loggerProvider.getLogger(name);
+        return this._loggerProvider.getLogger(name, version_js_1.SDK_VERSION);
     }
     getInternalLogger() {
         return this._internalLogger;
@@ -306,8 +316,7 @@ class StructSDK {
             return await fn();
         }
         const agentName = options.name;
-        const sessionId = options.sessionId ?? (0, node_crypto_1.randomUUID)();
-        const parentSessionId = (0, context_js_1.getSessionId)();
+        const explicitSessionId = options.sessionId;
         const tracer = this.getTracer("struct-sdk");
         // Parent the new agent span on the nearest enclosing agent span (if
         // any) so nested `struct.agent()` / `struct.tool()` calls build a
@@ -316,16 +325,68 @@ class StructSDK {
         // nothing to hang off. We do NOT rely on the global OTel context
         // manager being installed — the SDK manages its own parent chain via
         // StructContext ALS to stay neutral in multi-tenant OTel setups.
-        const parentSpan = (0, context_js_1.getAgentSpan)();
-        const parentCtx = parentSpan
-            ? api_1.trace.setSpan(api_1.context.active(), parentSpan)
-            : api_1.context.active();
+        //
+        // Captured BEFORE we resolve/overwrite anything below — mirrors
+        // python's `enclosing_session_id` / `enclosing_agent_span` capture at
+        // core.py:625-626. Used to (1) resolve this agent's own session id via
+        // ambient inheritance, (2) detect break-out, and (3) decide whether to
+        // stamp `struct.agent.parent_session_id`.
+        const enclosingSessionId = (0, context_js_1.getSessionId)();
+        const enclosingAgentSpan = (0, context_js_1.getAgentSpan)();
+        // ── Resolve sessionId (REVISION R1 grouping model) ──────────────────
+        // Resolution order: explicit caller arg > ambient (enclosing agent) >
+        // session-less. We never fabricate a uuid — a caller that omits
+        // sessionId with no enclosing agent gets a SESSION-LESS run (no
+        // `gen_ai.conversation.id` attribute at all). Ports core.py:628-644
+        // exactly (`self._session_id = ""` there is `undefined` here).
+        const sessionId = explicitSessionId !== undefined
+            ? explicitSessionId
+            : enclosingSessionId !== undefined
+                ? enclosingSessionId
+                : undefined;
+        // ── Break-out detection (spawned-by Link) ───────────────────────────
+        // Caller supplied an EXPLICIT session id that differs from the
+        // enclosing agent's session AND there IS an enclosing Struct agent
+        // span in scope. This agent starts a fresh ROOT trace (no OTel
+        // parent) and carries a causal Link back to the enclosing agent's
+        // span context. Ports struct_sdk.core._AgentContext._start_span's
+        // `break_out` branch (struct-sdk-python/src/struct_sdk/core.py:651-656)
+        // exactly.
+        const breakOut = explicitSessionId !== undefined &&
+            enclosingSessionId !== undefined &&
+            explicitSessionId !== enclosingSessionId &&
+            enclosingAgentSpan !== undefined;
+        // ── Parentage: PURE NEST (Option D) ─────────────────────────────────
+        // A non-break-out agent nests under whatever OTel span is active — the
+        // host's ambient context — like every peer LLM/agent SDK. We do NOT
+        // second-guess the active span or unilaterally re-root: the old
+        // `foreignRoot` heuristic detached from ANY active span and so ripped
+        // agents out of legitimate host request traces. Cross-conversation
+        // grouping is carried by gen_ai.conversation.id, never by trace
+        // parentage. A runtime that propagates a stale/unwanted span across a
+        // boundary (e.g. our own persistent_agent Temporal workflow span) clears
+        // it at the SOURCE, never here. (A provenance-gated detach — re-root only
+        // a leaked Struct-OWNED span — is a documented, deferred follow-up.)
+        let startContext;
+        let links;
+        if (breakOut) {
+            // Explicit different session under another Struct agent: fresh ROOT
+            // trace + a spawned-by Link. The one deliberate, opt-in re-root.
+            // enclosingAgentSpan is guaranteed defined by the breakOut guard above.
+            links = [{ context: enclosingAgentSpan.spanContext() }];
+            startContext = api_1.ROOT_CONTEXT;
+        }
+        else {
+            startContext = enclosingAgentSpan
+                ? api_1.trace.setSpan(api_1.context.active(), enclosingAgentSpan)
+                : api_1.context.active();
+        }
         // Span creation itself can fail (custom tracer, broken context). If it
         // does, fall through to running `fn` directly so the user's call
         // always runs uninstrumented rather than blowing up on telemetry.
         let span;
         safe(() => {
-            span = tracer.startSpan(`invoke_agent ${agentName}`, { kind: api_1.SpanKind.INTERNAL }, parentCtx);
+            span = tracer.startSpan(`invoke_agent ${agentName}`, { kind: api_1.SpanKind.INTERNAL, links }, startContext);
         }, "agent.start_span", this._internalLogger);
         if (span === undefined) {
             return await fn();
@@ -333,7 +394,10 @@ class StructSDK {
         const startedSpan = span;
         safe(() => {
             startedSpan.setAttribute(semconv_js_1.GEN_AI.OPERATION_NAME, "invoke_agent");
-            startedSpan.setAttribute(semconv_js_1.GEN_AI.PROVIDER_NAME, "struct");
+            // gen_ai.provider.name is NOT set here: this layer is
+            // provider-agnostic, and a framework name ("struct") isn't a
+            // provider. The first child inference call stamps the real one via
+            // propagateProviderToParent (write-once, best knowledge).
             startedSpan.setAttribute(semconv_js_1.GEN_AI.AGENT_NAME, agentName);
             // gen_ai.agent.id is the stable identifier of the agent
             // DEFINITION. Only set it when the caller provides one — we do
@@ -346,17 +410,24 @@ class StructSDK {
                 startedSpan.setAttribute(semconv_js_1.GEN_AI.AGENT_VERSION, options.version);
             }
             // gen_ai.conversation.id is the spec-blessed name for
-            // session/thread id.
-            startedSpan.setAttribute(semconv_js_1.GEN_AI.CONVERSATION_ID, sessionId);
-            // Always set parent_session_id when there's a parent agent — even
-            // when the value matches sessionId (which happens when a nested
-            // ``struct.agent()`` inherits ambient session). The attribute is
-            // structural ("this agent has a parent agent"), not a uniqueness
-            // marker. The UI uses it to render an inline subagent expansion
-            // under the triggering call (vs the drill-in flow used when
-            // sessionIds differ).
-            if (parentSessionId) {
-                startedSpan.setAttribute(semconv_js_1.STRUCT.AGENT_PARENT_SESSION_ID, parentSessionId);
+            // session/thread id. Omitted when session-less (never fabricated).
+            // Ports core.py:723-725 (`if self._session_id:`) exactly.
+            if (sessionId) {
+                startedSpan.setAttribute(semconv_js_1.GEN_AI.CONVERSATION_ID, sessionId);
+            }
+            // ``struct.agent.parent_session_id`` is a SPAWNED-BY marker — set it
+            // ONLY when this agent has an enclosing session that DIFFERS from
+            // its own resolved session id. An inline nested agent (same session
+            // as the enclosing agent, whether by explicit same id or ambient
+            // inheritance) already has its parent relationship encoded by the
+            // OTel span tree (ParentSpanId) — stamping
+            // parent_session_id === own sessionId would be self-referential
+            // noise. Structure comes from the tree/Link, not this attr
+            // (Link-canonical decision). Ports core.py:736-745 exactly (both
+            // the break-out and the "legacy" differing-id-no-span branches
+            // collapse to this one condition).
+            if (enclosingSessionId !== undefined && enclosingSessionId !== sessionId) {
+                startedSpan.setAttribute(semconv_js_1.STRUCT.AGENT_PARENT_SESSION_ID, enclosingSessionId);
             }
             if (options.metadata) {
                 for (const [key, value] of Object.entries(options.metadata)) {
@@ -369,6 +440,7 @@ class StructSDK {
             conversationId: sessionId,
             agentSpan: startedSpan,
             pendingToolCalls: {},
+            manualAgentSpan: startedSpan,
         }, async () => {
             const activeCtx = api_1.trace.setSpan(api_1.context.active(), startedSpan);
             try {
@@ -420,7 +492,8 @@ class StructSDK {
         const startedSpan = span;
         safe(() => {
             startedSpan.setAttribute(semconv_js_1.GEN_AI.OPERATION_NAME, "execute_tool");
-            startedSpan.setAttribute(semconv_js_1.GEN_AI.PROVIDER_NAME, "struct");
+            // 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, toolName);
             if (toolCallId) {
                 startedSpan.setAttribute(semconv_js_1.GEN_AI.TOOL_CALL_ID, toolCallId);
@@ -436,7 +509,28 @@ class StructSDK {
             if (this.captureContent && result !== undefined && result !== null) {
                 safe(() => startedSpan.setAttribute(semconv_js_1.GEN_AI.TOOL_CALL_RESULT, (0, truncation_js_1.safeJsonStringify)(result).slice(0, 8192)), "tool.set_result_attr", this._internalLogger);
             }
-            safe(() => startedSpan.setStatus({ code: api_1.SpanStatusCode.OK }), "tool.set_ok_status", this._internalLogger);
+            if (toolResultSignalsError(result)) {
+                safe(() => {
+                    startedSpan.setAttribute(semconv_js_1.ERROR_TYPE, "tool_error");
+                    // The status message is content placed on a SPAN — it follows
+                    // the span-content routing gate (emitSpanContent), not merely
+                    // "any capture on": under EventOnly (the default) content
+                    // routes to log events, so span text gets the fixed literal.
+                    // Deliberate boundary: gen_ai.tool.call.result above stays on
+                    // captureContent — tool spans have no log-event equivalent for
+                    // results, so the attribute is the sanctioned tool-content
+                    // channel in every non-None mode. Mirrors python _note_result.
+                    startedSpan.setStatus({
+                        code: api_1.SpanStatusCode.ERROR,
+                        message: this.emitSpanContent
+                            ? toolErrorStatusMessage(result)
+                            : "tool returned is_error=true",
+                    });
+                }, "tool.set_tool_error_status", this._internalLogger);
+            }
+            else {
+                safe(() => startedSpan.setStatus({ code: api_1.SpanStatusCode.OK }), "tool.set_ok_status", this._internalLogger);
+            }
             return result;
         }
         catch (err) {
@@ -458,4 +552,65 @@ function recordError(span, err) {
         span.recordException(err);
     }
 }
+/**
+ * Read one property from untrusted host data, isolating the read in its
+ * own try — a hostile getter/Proxy trap on ONE key must never throw into
+ * tool()'s try block (rejecting the host's successful call) nor mask a
+ * readable value on a SIBLING key (callers probe each supported alias
+ * independently). Mirrors python `_safe_probe` — keep in lockstep.
+ */
+function safeProbe(obj, key) {
+    if (typeof obj !== "object" || obj === null)
+        return undefined;
+    try {
+        return obj[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Whether a tool's RETURN VALUE signals in-band failure (MCP
+ * CallToolResult.isError / Anthropic tool_result.is_error). Strictly
+ * boolean `true` on the top-level object — truthy strings/numbers and
+ * nested flags do not trigger (host data is untrusted; be conservative).
+ * Each alias is probed independently so a hostile getter on one cannot
+ * mask the other. Mirrors python `_tool_result_signals_error`.
+ */
+function toolResultSignalsError(result) {
+    return (safeProbe(result, "isError") === true ||
+        safeProbe(result, "is_error") === true);
+}
+/** Short status message from an error result's content, else a fixed one.
+ *
+ * TOTAL FUNCTION: never throws and does bounded work. It runs inside the
+ * safe() closure that also sets span status — a hostile Proxy whose
+ * `length`/index traps throw must not abort that closure (which would
+ * leave the span UNSET instead of ERROR). Two layers: per-key safeProbe
+ * isolation (one hostile item cannot mask a later readable one) INSIDE a
+ * whole-body catch (collection machinery itself is untrusted), index
+ * loop instead of for..of (iterator protocol is trappable), traversal
+ * capped at 20 items. Mirrors python `_tool_error_status_message`. */
+function toolErrorStatusMessage(result) {
+    try {
+        const content = safeProbe(result, "content");
+        if (typeof content === "string" && content)
+            return content.slice(0, 256);
+        if (Array.isArray(content)) {
+            const len = Math.min(content.length, 20);
+            for (let i = 0; i < len; i++) {
+                const item = safeProbe(content, String(i));
+                const text = safeProbe(item, "text");
+                // Truthiness (not just typeof) matches the python twin: empty-string
+                // text items are skipped, falling through to the fixed message.
+                if (typeof text === "string" && text)
+                    return text.slice(0, 256);
+            }
+        }
+    }
+    catch {
+        // Hostile collection — fall through to the fixed message.
+    }
+    return "tool returned is_error=true";
+}
 //# sourceMappingURL=core.js.map

package/dist/commonjs/events.d.ts

@@ -1,12 +1,23 @@
-import { type Logger } from "@opentelemetry/api-logs";
+import type { Logger } from "@opentelemetry/api-logs";
+import type { Span } from "@opentelemetry/api";
 /**
  * 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 declare function emitAnthropicMessageEvents(logger: Logger, messages: unknown, system: unknown): void;
+export declare function emitAnthropicMessageEvents(logger: Logger, messages: unknown, system: unknown, span?: Span, provider?: string): void;
+/** Emit a gen_ai.choice LogRecord for an Anthropic response. */
+export declare function emitAnthropicChoiceEvent(logger: Logger, contentBlocks: unknown, stopReason: string | null | undefined, span?: Span, provider?: string): void;
 /**
- * Emit a gen_ai.choice LogRecord for an Anthropic response.
- * Port of _emit_choice_event from anthropic.py.
+ * 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 declare function emitAnthropicChoiceEvent(logger: Logger, contentBlocks: unknown, stopReason: string | null | undefined): void;
+export declare function emitOpenAIInputMessageEvents(logger: Logger, input: unknown, instructions: unknown, span?: Span, provider?: string): void;
+/**
+ * Emit the gen_ai.choice LogRecord from an OpenAI response.output.
+ * `finishReason` is mapped inside this emitter using mapChoiceFinishReason.
+ */
+export declare function emitOpenAIChoiceEvent(logger: Logger, output: unknown, finishReason: string | undefined, span?: Span, provider?: string): void;
 //# sourceMappingURL=events.d.ts.map

package/dist/commonjs/events.js

@@ -2,40 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitAnthropicMessageEvents = emitAnthropicMessageEvents;
 exports.emitAnthropicChoiceEvent = emitAnthropicChoiceEvent;
-const api_1 = require("@opentelemetry/api");
-const api_logs_1 = require("@opentelemetry/api-logs");
-const context_js_1 = require("./context.js");
+exports.emitOpenAIInputMessageEvents = emitOpenAIInputMessageEvents;
+exports.emitOpenAIChoiceEvent = emitOpenAIChoiceEvent;
+const genai_content_js_1 = require("./genai-content.js");
 const semconv_js_1 = require("./semconv.js");
-const truncation_js_1 = require("./truncation.js");
 const anthropic_content_js_1 = require("./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 = (0, context_js_1.getSessionId)();
-    const attributes = {
-        [semconv_js_1.EVENT_NAME]: eventName,
-        body: payload,
-        ...extraAttrs,
-    };
-    if (sessionId)
-        attributes[semconv_js_1.GEN_AI.CONVERSATION_ID] = sessionId;
-    logger.emit({
-        body: eventName,
-        severityNumber: api_logs_1.SeverityNumber.INFO,
-        attributes,
-        context: api_1.context.active(),
-    });
-}
+const openai_content_js_1 = require("./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.
  */
-function emitAnthropicMessageEvents(logger, messages, system) {
+function emitAnthropicMessageEvents(logger, messages, system, span, provider = "anthropic") {
     if (!Array.isArray(messages))
         return;
     let msgIndex = 0;
@@ -45,17 +23,14 @@ function emitAnthropicMessageEvents(logger, messages, system) {
             : Array.isArray(system)
                 ? (0, anthropic_content_js_1.contentToParts)(system)
                 : [{ type: "text", content: String(system) }];
-        emitLogRecord({
+        (0, genai_content_js_1.emitMessageEvent)({
             logger,
+            role: "system",
+            parts,
             eventName: semconv_js_1.EVENT_NAMES.SYSTEM_MESSAGE,
-            payload: (0, truncation_js_1.safeJsonStringify)({
-                role: "system",
-                parts: (0, truncation_js_1.truncateParts)(parts),
-            }),
-            extraAttrs: {
-                [semconv_js_1.GEN_AI.SYSTEM]: "anthropic",
-                [semconv_js_1.GEN_AI.MESSAGE_INDEX]: msgIndex,
-            },
+            provider,
+            messageIndex: msgIndex,
+            span,
         });
         msgIndex++;
     }
@@ -66,38 +41,86 @@ function emitAnthropicMessageEvents(logger, messages, system) {
         const role = typeof m.role === "string" ? m.role : "user";
         const parts = (0, anthropic_content_js_1.contentToParts)(m.content);
         const eventName = semconv_js_1.ROLE_TO_EVENT_NAME[role] ?? `gen_ai.${role}.message`;
-        emitLogRecord({
+        (0, genai_content_js_1.emitMessageEvent)({
             logger,
+            role,
+            parts,
             eventName,
-            payload: (0, truncation_js_1.safeJsonStringify)({ role, parts: (0, truncation_js_1.truncateParts)(parts) }),
-            extraAttrs: {
-                [semconv_js_1.GEN_AI.SYSTEM]: "anthropic",
-                [semconv_js_1.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.
- */
-function emitAnthropicChoiceEvent(logger, contentBlocks, stopReason) {
+/** Emit a gen_ai.choice LogRecord for an Anthropic response. */
+function emitAnthropicChoiceEvent(logger, contentBlocks, stopReason, span, provider = "anthropic") {
     const parts = (0, anthropic_content_js_1.contentToParts)(contentBlocks);
     const mappedReason = (stopReason && (semconv_js_1.ANTHROPIC_FINISH_REASON_MAP[stopReason] ?? stopReason)) ||
         "stop";
-    const payload = (0, truncation_js_1.safeJsonStringify)({
-        index: 0,
-        finish_reason: mappedReason,
-        message: { role: "assistant", parts: (0, truncation_js_1.truncateParts)(parts) },
+    (0, genai_content_js_1.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.
+ */
+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) }];
+        (0, genai_content_js_1.emitMessageEvent)({
+            logger,
+            role: "system",
+            parts,
+            eventName: semconv_js_1.EVENT_NAMES.SYSTEM_MESSAGE,
+            provider,
+            messageIndex: msgIndex,
+            span,
+        });
+        msgIndex++;
+    }
+    for (const item of (0, openai_content_js_1.normalizeInput)(input)) {
+        const mapped = (0, openai_content_js_1.inputItemToEvent)(item);
+        if (!mapped)
+            continue;
+        const [eventName, role, parts] = mapped;
+        (0, genai_content_js_1.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.
+ */
+function emitOpenAIChoiceEvent(logger, output, finishReason, span, provider = "openai") {
+    const parts = [];
+    for (const item of Array.isArray(output) ? output : []) {
+        parts.push(...(0, openai_content_js_1.outputItemToChoiceParts)(item));
+    }
+    (0, genai_content_js_1.emitChoiceEvent)({
         logger,
-        eventName: semconv_js_1.EVENT_NAMES.CHOICE,
-        payload,
-        extraAttrs: {
-            [semconv_js_1.GEN_AI.SYSTEM]: "anthropic",
-        },
+        parts,
+        finishReason: (0, openai_content_js_1.mapChoiceFinishReason)(finishReason),
+        provider,
+        span,
     });
 }
 //# sourceMappingURL=events.js.map

package/dist/commonjs/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