@struct-ai/sdk 0.3.17 → 0.4.3

package/README.md

@@ -1,8 +1,9 @@
 # @struct-ai/sdk
 
 Struct agent observability SDK for TypeScript/Node.js. Auto-instruments AI agent
-frameworks — the Anthropic SDK and LangChain.js — and emits OpenTelemetry
-traces + logs to [struct.ai](https://struct.ai) with zero config.
+frameworks and LLM SDKs — the Anthropic SDK, the OpenAI SDK (Responses API),
+and LangChain.js — and emits OpenTelemetry traces + logs to
+[struct.ai](https://struct.ai) with zero config.
 
 This is the TypeScript port of [`struct-sdk`](https://pypi.org/project/struct-sdk/)
 (Python). Span names, attribute keys, and log event shapes are identical across
@@ -13,7 +14,7 @@ the two SDKs so the server processes both uniformly.
 ```bash
 npm install @struct-ai/sdk
 # optional — the SDK auto-instruments these if present
-npm install @anthropic-ai/sdk @langchain/core @langchain/langgraph
+npm install @anthropic-ai/sdk openai @langchain/core @langchain/langgraph
 ```
 
 Requires Node 18+.
@@ -57,6 +58,7 @@ await struct.agent({ name: "checkout" }, async () => {
 |---|---|---|---|
 | `@anthropic-ai/sdk` | `Messages.prototype.create`, `.stream` | `chat {model}` | Cache-token accounting, streaming with tool-use reconstruction. Defers to a LangChain `BaseChatModel` call already in progress (e.g. `ChatAnthropic`) so the two integrations don't double-emit — see ownership order below |
 | `@anthropic-ai/bedrock-sdk`, `@anthropic-ai/vertex-sdk` | `Messages.prototype.*` | `chat {model}` | Best-effort, if installed |
+| `openai` | `Responses.prototype.create` | `chat {model}` | **Responses API, non-streaming calls only** — `responses.create({stream: true})` and `responses.stream()` pass through untouched (no span), and `chat.completions` is not instrumented. Cache-read/cache-write/reasoning token accounting; `function_call` → `struct.tool()` id auto-linkage. Requires an openai release with the Responses API (v4 releases without it are a graceful no-op). Defers to a LangChain call in progress, same as Anthropic |
 | `@langchain/core` `BaseChatModel` | `.invoke`, `.stream` | `chat {model}` | Always owns the `chat` span for `ChatAnthropic`/etc. calls, even when a provider-direct instrumentor (e.g. the Anthropic patch) is also active — the framework layer outranks the provider layer (single span; see [AGENTS.md](./AGENTS.md) §5) |
 | `@langchain/core` `StructuredTool` | `.invoke` | `execute_tool {name}` | Extracts `tool_call_id` from LangChain ToolCall input or pending queue |
 | `@langchain/core` `BaseRetriever` | `.invoke` | `retrieval {name}` | |
@@ -166,6 +168,37 @@ await struct.agent({ name: "checkout" }, async () => {
 `@anthropic-ai/sdk`, `@anthropic-ai/bedrock-sdk`, and `@anthropic-ai/vertex-sdk`
 are all auto-instrumented for chat spans.
 
+#### OpenAI SDK (raw, Responses API)
+
+Same rule as raw Anthropic — chat spans emit automatically; wrap your agent
+loop and tools yourself:
+
+```ts
+import { struct } from "@struct-ai/sdk";
+struct.init({ ingestKey: "pk-...", serviceName: "support-agent" });
+
+import OpenAI from "openai";
+const client = new OpenAI();
+
+await struct.agent({ name: "support" }, async () => {
+  const resp = await client.responses.create({
+    model: "gpt-5.5",
+    input: "triage this ticket",
+  });
+
+  // tool_call_id is auto-filled from the preceding response's function_call.
+  await struct.tool({ name: "lookup_order" }, async () => {
+    return await lookupOrder(resp);
+  });
+});
+```
+
+**Scope:** the OpenAI integration covers **non-streaming `responses.create()`**
+only. Streaming calls (`stream: true` / `responses.stream()`) run unmodified and
+emit no span, and `chat.completions` is not instrumented. Azure OpenAI clients
+(`AzureOpenAI`) share the same `Responses` class and are covered by the same
+patch.
+
 #### LangChain `BaseChatModel` (no agent/graph)
 
 If you call `ChatAnthropic.invoke(...)` (or any other `BaseChatModel`)
@@ -206,13 +239,13 @@ struct.init({
 ```
 
 - **`EventOnly`** (default): per-message content lands on OTel log records
-  (`gen_ai.{user,assistant,system,tool}.message`, `gen_ai.choice`). Spans carry
-  metadata only.
+  (`gen_ai.{user,assistant,system,tool}.message`, `gen_ai.choice`).
 - **`SpanOnly`**: content on span attributes (`gen_ai.input.messages`,
   `gen_ai.output.messages`).
 - **`SpanAndEvent`**: both.
-- **`None`**: no content captured. Token counts, tool call IDs, finish reasons,
-  and other metadata still flow.
+- **`None`**: no content captured, anywhere — no log events, no span content
+  attributes. Token counts, tool call IDs, finish reasons, and other metadata
+  still flow.
 
 Set `captureContent: false` for the legacy bool API (equivalent to
 `ContentCaptureMode.None`).
@@ -252,7 +285,7 @@ the troubleshooting section below for the workaround.
 Emits attributes per the OTel GenAI semantic conventions:
 
 - `gen_ai.operation.name` — `chat`, `execute_tool`, `invoke_agent`, `retrieval`
-- `gen_ai.provider.name` — `anthropic`, `openai`, `langchain`, `struct`, …
+- `gen_ai.provider.name` — the GenAI provider on inference spans (`anthropic`, `openai`, …); platform-routed calls report the platform value (`aws.bedrock`, `gcp.vertex_ai`, `azure.ai.openai`) when detectable from the client. `invoke_agent` spans inherit the provider from their first child inference call (omitted when no model is reached); `execute_tool`/`retrieval` spans carry no provider.
 - `gen_ai.request.{model, max_tokens, temperature, top_p, top_k, stop_sequences}`
 - `gen_ai.response.{model, id, finish_reasons}`
 - `gen_ai.usage.{input_tokens, output_tokens, cache_read.input_tokens, cache_creation.input_tokens}`
@@ -260,6 +293,28 @@ Emits attributes per the OTel GenAI semantic conventions:
 - `gen_ai.tool.{name, call.id, call.arguments, call.result}`
 - `error.type` + `StatusCode.ERROR` on failures
 
+### `error.type` values emitted
+
+The OTel conventions ask instrumentations to document the error values they
+report ("Instrumentations SHOULD document the list of errors they report").
+This SDK emits exactly two kinds of value, both alongside span
+`StatusCode.ERROR`:
+
+| Value | When | Meaning |
+| --- | --- | --- |
+| exception class name (e.g. `TypeError`, `APIConnectionError`) | the instrumented call threw | We failed to execute the request. Also records an OTel exception event. |
+| `tool_error` | an `execute_tool` span whose result signalled failure **in band** — Anthropic `tool_result` blocks with `is_error: true`, MCP `CallToolResult.isError`, or a LangChain `ToolMessage` with `status: "error"` | The tool ran and reported a failure back to the model (bad arguments, a domain "no"), so the model can self-correct. No exception object exists, so no class name is available. |
+
+`tool_error` is a deliberate low-cardinality sentinel, which the `error.type`
+convention explicitly permits ("another low-cardinality error identifier"; a
+custom value MAY be used where no well-known one applies). The same split is
+used by OpenTelemetry's MCP instrumentation in OpenLLMetry, which likewise
+reports `error.type="tool_error"` for the `isError` path and the exception
+class name otherwise. Matches the Python SDK.
+
+The distinction is what lets a monitor page on genuine execution failures
+while excluding failures the model already saw and can recover from.
+
 Note: `gen_ai.usage.input_tokens` for Anthropic is the TRUE total — we add back
 `cache_read_input_tokens + cache_creation_input_tokens` (which Anthropic's raw
 response excludes). Matches the Python SDK.
@@ -270,21 +325,33 @@ response excludes). Matches the Python SDK.
   `test/live/**`.
 - `pnpm typecheck` — `tsc --noEmit`.
 - `pnpm build` — `tshy`, producing the dual ESM/CJS `dist/`.
-- `pnpm test:live` — the live real-model suite: real `@langchain/anthropic` +
-  real Anthropic API + real `@langchain/langgraph`, verifying emitted spans
-  in-memory (no ingester needed). Skips cleanly (exit 0, all tests skipped)
-  when no API key is present — safe to leave in normal CI.
+- `pnpm test:live` — the live real-model suite: real provider SDKs
+  (`@anthropic-ai/sdk`, `openai`) and frameworks (`@langchain/*`) against the
+  real Anthropic / OpenAI APIs, verifying the emitted spans + log events
+  **in-memory** (no ingester needed). Each gated block skips cleanly (exit 0)
+  when its API key is absent — safe to leave in normal CI.
 
-  To actually run it, point `STRUCT_LIVE_ENV_FILE` at a file containing
-  `ANTHROPIC_API_KEY=...` (dotenv-style `KEY=value` lines; quotes optional).
-  The path is never committed to the repo — it's supplied per-invocation:
+  To run it, point `STRUCT_LIVE_ENV_FILE` at a file with the keys you want to
+  exercise (`ANTHROPIC_API_KEY=...` and/or `OPENAI_API_KEY=...`; dotenv-style
+  `KEY=value` lines, quotes optional). The path is never committed — it's
+  supplied per-invocation:
 
   ```bash
   STRUCT_LIVE_ENV_FILE=/path/to/your/.env pnpm test:live
   ```
 
-  Uses the cheapest current Anthropic model alias with small `max_tokens`
-  budgets — a handful of real API calls per run, not dozens.
+  Only blocks whose key is present run, so a file with both keys runs both the
+  Anthropic and OpenAI suites (a handful of small real calls each — cheap model
+  aliases, small token budgets).
+
+  **Full-pipeline e2e** (`test/live/openai-ingest-e2e.live.test.ts`)
+  additionally ships the emitted telemetry to a *real* ingest endpoint and
+  flushes it, so you can confirm a change travels the whole path
+  (SDK → OTLP export → your Struct instance). It's gated on `STRUCT_INGEST_URL`
+  + `STRUCT_INGEST_KEY` (on top of `OPENAI_API_KEY`), so it stays skipped unless
+  you deliberately supply real ingest credentials. It still self-asserts the
+  span shape in-memory; confirming the span actually *landed* means querying
+  your Struct instance's telemetry — see [AGENTS.md](./AGENTS.md).
 - `pnpm test:parity` — the cross-language conformance harness: drives the
   same canonical agent topology through both this SDK and `struct-sdk-python`
   and diffs their normalized span shapes, failing (non-zero exit) on any

package/dist/commonjs/context.d.ts

@@ -53,4 +53,23 @@ export declare function snapshotStore(): StructContext | undefined;
 export declare function runWithStore<T>(store: StructContext | undefined, fn: () => T): T;
 /** Test-only: run `fn` inside a completely fresh context (no parent store). */
 export declare function runInFreshContext<T>(fn: () => T): T;
+/**
+ * Write-once `gen_ai.provider.name` on an invoke_agent span.
+ *
+ * CONTRACT: `agentSpan` is always an SDK-OWNED span — created by our own
+ * tracer in `struct.agent()` or the LangChain handler and delivered via the
+ * ALS store / run map, which nothing else writes. Never a host object. So
+ * the industry-standard owned-object pattern applies (state lives ON the
+ * object — Sentry/dd-trace private span fields, OTel JS symbol markers): a
+ * private Symbol sentinel set after a successful write. No registries or
+ * lifecycle bookkeeping — those are for FOREIGN objects.
+ *
+ * Semantics: "a real child provider" — racing children with different
+ * providers may pick either; the sentinel is set only after a successful
+ * write so a transient failure can be retried. Parity: python
+ * `stamp_provider_once`.
+ */
+export declare function stampProviderOnce(agentSpan: Span | undefined, provider: string | undefined): void;
+/** Stamp the ambient agent span with the child call's provider (write-once). */
+export declare function propagateProviderToParent(provider: string | undefined): void;
 //# sourceMappingURL=context.d.ts.map

package/dist/commonjs/context.js

@@ -14,6 +14,8 @@ exports.pushPendingToolCalls = pushPendingToolCalls;
 exports.snapshotStore = snapshotStore;
 exports.runWithStore = runWithStore;
 exports.runInFreshContext = runInFreshContext;
+exports.stampProviderOnce = stampProviderOnce;
+exports.propagateProviderToParent = propagateProviderToParent;
 const node_async_hooks_1 = require("node:async_hooks");
 const als = new node_async_hooks_1.AsyncLocalStorage();
 function getStore() {
@@ -110,4 +112,60 @@ function runWithStore(store, fn) {
 function runInFreshContext(fn) {
     return als.run({}, fn);
 }
+/**
+ * Write-once `gen_ai.provider.name` on an invoke_agent span.
+ *
+ * The GenAI spec puts `gen_ai.provider.name` on invoke_agent spans, but the
+ * layer that CREATES those spans (`struct.agent()`, the LangChain handler) is
+ * provider-agnostic and can't know the value yet — only the child inference
+ * call can. The first chat call within the agent scope stamps it (best
+ * knowledge; first one wins); an agent that never reaches a model omits the
+ * attribute rather than carrying a framework name. Parity: python
+ * `_genai_content.stamp_provider_once`.
+ */
+const PROVIDER_STAMPED = Symbol("struct.providerStamped");
+/**
+ * Write-once `gen_ai.provider.name` on an invoke_agent span.
+ *
+ * CONTRACT: `agentSpan` is always an SDK-OWNED span — created by our own
+ * tracer in `struct.agent()` or the LangChain handler and delivered via the
+ * ALS store / run map, which nothing else writes. Never a host object. So
+ * the industry-standard owned-object pattern applies (state lives ON the
+ * object — Sentry/dd-trace private span fields, OTel JS symbol markers): a
+ * private Symbol sentinel set after a successful write. No registries or
+ * lifecycle bookkeeping — those are for FOREIGN objects.
+ *
+ * Semantics: "a real child provider" — racing children with different
+ * providers may pick either; the sentinel is set only after a successful
+ * write so a transient failure can be retried. Parity: python
+ * `stamp_provider_once`.
+ */
+function stampProviderOnce(agentSpan, provider) {
+    try {
+        if (!agentSpan || !provider)
+            return;
+        const marked = agentSpan;
+        if (marked[PROVIDER_STAMPED])
+            return;
+        agentSpan.setAttribute("gen_ai.provider.name", provider);
+        try {
+            marked[PROVIDER_STAMPED] = true;
+        }
+        catch {
+            /* frozen span — worst case a later child re-stamps a real provider */
+        }
+    }
+    catch {
+        /* never fail the application for telemetry */
+    }
+}
+/** Stamp the ambient agent span with the child call's provider (write-once). */
+function propagateProviderToParent(provider) {
+    try {
+        stampProviderOnce(getAgentSpan(), provider);
+    }
+    catch {
+        /* never fail the application for telemetry */
+    }
+}
 //# sourceMappingURL=context.js.map

package/dist/commonjs/core.js

@@ -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 */
         }
     }
 }
@@ -384,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
@@ -479,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);
@@ -495,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) {
@@ -517,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.PROVIDER_NAME]: "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.PROVIDER_NAME]: "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.PROVIDER_NAME]: "anthropic",
-        },
+        parts,
+        finishReason: (0, openai_content_js_1.mapChoiceFinishReason)(finishReason),
+        provider,
+        span,
     });
 }
 //# sourceMappingURL=events.js.map