weflayr 0.27.0 → 0.29.0

package/dist/src/instrumentation/openai/get_responses_telemetry.d.ts

@@ -0,0 +1,89 @@
+/**
+ * OpenAI Responses (`/v1/responses`) telemetry complement.
+ *
+ * `@traceloop/instrumentation-openai` wraps `Responses.create` but records far
+ * less than the Python OpenLLMetry instrumentor does for the same call, so
+ * without this complement the two weflayr SDKs would store different rows for
+ * the same request. Three gaps, all closed here:
+ *
+ *   1. Input messages. Upstream stringifies the whole `input` into a single
+ *      `{role: "user", parts: [{type: "text", content: "<JSON>"}]}` part. That
+ *      loses every role and part type, and it buries an inline image or
+ *      document's base64 inside a text string, where `strip-media-payloads`
+ *      cannot see it and the payload would reach the queue. This rebuilds the
+ *      per-role, per-part shape the Python instrumentor emits.
+ *   2. Response side. Upstream records only the output text, so a tool call or
+ *      a reasoning summary is lost, the finish reason is never `tool_call`, and
+ *      `input_tokens_details` / `output_tokens_details` (cached tokens, the
+ *      cache-write count, reasoning tokens) are dropped entirely.
+ *   3. Streamed calls are not instrumented at all upstream: its wrapper ends
+ *      the span with request attributes only and returns the stream untouched,
+ *      so a streamed call would be stored as a real call that cost nothing.
+ *      This takes over that one branch: `stream: true` bypasses the upstream
+ *      wrapper and runs our own span, accumulating the stream's events.
+ *
+ * Gap 3's takeover ends the span when the stream is iterated, which is how a
+ * stream is consumed in practice. A stream handed to `tee()` or
+ * `toReadableStream()` instead is never iterated, so its span never ends and
+ * the call is not recorded: a missing call, never a call recorded as free.
+ *
+ * It also stamps xAI's document searches, which neither instrumentor records:
+ * xAI reads a document attached to a Responses request by searching it with its
+ * own tool, and bills each search, reported as
+ * `usage.server_side_tool_usage_details.document_search_calls`
+ * (`weflayr.document_search.requests`).
+ *
+ * Inline media is the one deliberate divergence from the Python instrumentor's
+ * shape: an `input_file` carrying `file_data` becomes the byte-less
+ * `{type: "blob", mime_type}` stub rather than upstream's
+ * `{type: "file", file_id, filename}`, so an inline PDF pins the same stub here
+ * as it does on the chat endpoint. The Python complement makes the same repair.
+ * An `input_image` keeps its `data:` URI in a `uri` part, which the shared
+ * `strip-media-payloads` step already rewrites to that stub.
+ */
+import { type Span } from '@opentelemetry/api';
+type JsonObject = Record<string, any>;
+/** The request's `instructions` + `input` as OTel input messages. */
+export declare function buildResponsesInputMessages(params: JsonObject): JsonObject[];
+/** The request's function tools, in the flat shape the Responses API takes. */
+export declare function buildResponsesToolDefinitions(params: JsonObject): JsonObject[];
+/** The response's text, tool calls and reasoning summaries as one OTel message. */
+export declare function buildResponsesOutputMessages(response: JsonObject): JsonObject[];
+/** How many document searches a Responses answer is billed for, from xAI's
+ * `usage.server_side_tool_usage_details.document_search_calls`, or null when the
+ * usage reports none, e.g. `{server_side_tool_usage_details:
+ * {document_search_calls: 1}}` -> 1. */
+export declare function readBilledDocumentSearchCount(usage: any): number | null;
+/**
+ * Wrap a Responses stream's iterator so its events pass through untouched while
+ * the last response object seen is stamped on the span, which ends with the
+ * iteration.
+ *
+ * Mutates `stream` in place and returns it, so the caller still hands the app
+ * the exact object the openai client returned.
+ */
+export declare function recordResponsesStreamEvents(stream: any, span: Span, sendPrompts: boolean): any;
+export declare function traceStreamedCall({ instrumentation, openaiCreate, client, params, rest, }: {
+    instrumentation: any;
+    openaiCreate: any;
+    client: any;
+    params: any;
+    rest: any[];
+}): any;
+export declare class OpenAIResponsesInstrumentor {
+    private _patched;
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+    private _patchRequestSide;
+    private _patchResponseSide;
+    /**
+     * Own the streamed branch upstream leaves uninstrumented.
+     *
+     * Our wrapper sits outside upstream's, so a non-streamed call is delegated
+     * straight to it. A streamed call instead calls the function upstream wrapped
+     * (shimmer's `__original`), so only one span is ever created, and ends that
+     * span once the stream's events are consumed.
+     */
+    private _takeOverStreamedCalls;
+}
+export {};

package/dist/src/instrumentation/openai/get_responses_telemetry.js

@@ -0,0 +1,587 @@
+"use strict";
+/**
+ * OpenAI Responses (`/v1/responses`) telemetry complement.
+ *
+ * `@traceloop/instrumentation-openai` wraps `Responses.create` but records far
+ * less than the Python OpenLLMetry instrumentor does for the same call, so
+ * without this complement the two weflayr SDKs would store different rows for
+ * the same request. Three gaps, all closed here:
+ *
+ *   1. Input messages. Upstream stringifies the whole `input` into a single
+ *      `{role: "user", parts: [{type: "text", content: "<JSON>"}]}` part. That
+ *      loses every role and part type, and it buries an inline image or
+ *      document's base64 inside a text string, where `strip-media-payloads`
+ *      cannot see it and the payload would reach the queue. This rebuilds the
+ *      per-role, per-part shape the Python instrumentor emits.
+ *   2. Response side. Upstream records only the output text, so a tool call or
+ *      a reasoning summary is lost, the finish reason is never `tool_call`, and
+ *      `input_tokens_details` / `output_tokens_details` (cached tokens, the
+ *      cache-write count, reasoning tokens) are dropped entirely.
+ *   3. Streamed calls are not instrumented at all upstream: its wrapper ends
+ *      the span with request attributes only and returns the stream untouched,
+ *      so a streamed call would be stored as a real call that cost nothing.
+ *      This takes over that one branch: `stream: true` bypasses the upstream
+ *      wrapper and runs our own span, accumulating the stream's events.
+ *
+ * Gap 3's takeover ends the span when the stream is iterated, which is how a
+ * stream is consumed in practice. A stream handed to `tee()` or
+ * `toReadableStream()` instead is never iterated, so its span never ends and
+ * the call is not recorded: a missing call, never a call recorded as free.
+ *
+ * It also stamps xAI's document searches, which neither instrumentor records:
+ * xAI reads a document attached to a Responses request by searching it with its
+ * own tool, and bills each search, reported as
+ * `usage.server_side_tool_usage_details.document_search_calls`
+ * (`weflayr.document_search.requests`).
+ *
+ * Inline media is the one deliberate divergence from the Python instrumentor's
+ * shape: an `input_file` carrying `file_data` becomes the byte-less
+ * `{type: "blob", mime_type}` stub rather than upstream's
+ * `{type: "file", file_id, filename}`, so an inline PDF pins the same stub here
+ * as it does on the chat endpoint. The Python complement makes the same repair.
+ * An `input_image` keeps its `data:` URI in a `uri` part, which the shared
+ * `strip-media-payloads` step already rewrites to that stub.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIResponsesInstrumentor = void 0;
+exports.buildResponsesInputMessages = buildResponsesInputMessages;
+exports.buildResponsesToolDefinitions = buildResponsesToolDefinitions;
+exports.buildResponsesOutputMessages = buildResponsesOutputMessages;
+exports.readBilledDocumentSearchCount = readBilledDocumentSearchCount;
+exports.recordResponsesStreamEvents = recordResponsesStreamEvents;
+exports.traceStreamedCall = traceStreamedCall;
+const api_1 = require("@opentelemetry/api");
+const get_data_uri_mime_type_1 = require("../../get-data-uri-mime-type");
+const get_web_search_telemetry_1 = require("./get_web_search_telemetry");
+// traceloop's internal tag for the Responses request/response shape (its
+// `RESPONSES_TYPE`), the value it passes to `startSpan` / `_endSpan`.
+const RESPONSES_TYPE = 'responses';
+const INPUT_MESSAGES_ATTR = 'gen_ai.input.messages';
+const OUTPUT_MESSAGES_ATTR = 'gen_ai.output.messages';
+const TOOL_DEFINITIONS_ATTR = 'gen_ai.tool.definitions';
+const FINISH_REASONS_ATTR = 'gen_ai.response.finish_reasons';
+const RESPONSE_ID_ATTR = 'gen_ai.response.id';
+const RESPONSE_MODEL_ATTR = 'gen_ai.response.model';
+const INPUT_TOKENS_ATTR = 'gen_ai.usage.input_tokens';
+const OUTPUT_TOKENS_ATTR = 'gen_ai.usage.output_tokens';
+const TOTAL_TOKENS_ATTR = 'gen_ai.usage.total_tokens';
+// The dotted spelling the Python instrumentor emits on this path; the
+// normalizer reads it and the underscored chat spelling alike.
+const CACHE_READ_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_read.input_tokens';
+const CACHE_CREATION_INPUT_TOKENS_ATTR = 'gen_ai.usage.cache_creation_input_tokens';
+const REASONING_TOKENS_ATTR = 'gen_ai.usage.reasoning_tokens';
+const REQUEST_REASONING_EFFORT_ATTR = 'gen_ai.request.reasoning_effort';
+const REQUEST_REASONING_SUMMARY_ATTR = 'gen_ai.request.reasoning_summary';
+const RESPONSE_REASONING_EFFORT_ATTR = 'gen_ai.response.reasoning_effort';
+const RESPONSE_SERVICE_TIER_ATTR = 'openai.response.service_tier';
+const DOCUMENT_SEARCH_REQUESTS_ATTR = 'weflayr.document_search.requests';
+const TRACER_NAME = 'weflayr.instrumentation.openai_responses';
+// The output block types that make a completed response a tool call rather than
+// a plain answer, mirroring the Python instrumentor's finish-reason derivation.
+const TOOL_CALL_BLOCK_TYPES = [
+    'function_call',
+    'file_search_call',
+    'web_search_call',
+    'computer_call',
+    'code_interpreter_call',
+];
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** A tool call's arguments as an object, or the raw string when it is not JSON. */
+function parseArguments(rawArguments) {
+    if (rawArguments == null)
+        return null;
+    if (isJsonObject(rawArguments))
+        return rawArguments;
+    try {
+        return JSON.parse(String(rawArguments));
+    }
+    catch {
+        return rawArguments;
+    }
+}
+/**
+ * One `input` content block as an OTel message part.
+ *
+ * Example: `{type: "input_text", text: "hi"}` -> `{type: "text", content: "hi"}`;
+ * `{type: "input_file", filename: "a.pdf", file_data: "data:application/pdf;base64,..."}`
+ * -> `{type: "blob", mime_type: "application/pdf"}`.
+ */
+function buildInputPart(block) {
+    if (!isJsonObject(block)) {
+        return { type: 'text', content: String(block) };
+    }
+    const blockType = String(block.type ?? '');
+    if (blockType === 'text' || blockType === 'input_text' || blockType === 'output_text') {
+        return { type: 'text', content: block.text ?? '' };
+    }
+    if (blockType === 'image' || blockType === 'input_image' || blockType === 'output_image') {
+        if (block.image_url) {
+            return { type: 'uri', modality: 'image', uri: block.image_url };
+        }
+        return { type: 'file', modality: 'image', file_id: block.file_id ?? null };
+    }
+    if (blockType === 'file' || blockType === 'input_file' || blockType === 'output_file') {
+        const mimeType = (0, get_data_uri_mime_type_1.getDataUriMimeType)(String(block.file_data ?? ''));
+        if (mimeType !== null) {
+            return { type: 'blob', mime_type: mimeType };
+        }
+        return {
+            type: 'file',
+            file_id: block.file_id ?? null,
+            filename: block.filename ?? null,
+        };
+    }
+    // An unrecognized block keeps its own type, with the block itself as content.
+    return { type: blockType || 'unknown', content: block };
+}
+/** One `input` item as an OTel message, or null for an item type with no message. */
+function buildInputMessage(item) {
+    if (!isJsonObject(item)) {
+        return { role: 'user', parts: [{ type: 'text', content: String(item) }] };
+    }
+    const itemType = String(item.type ?? 'message');
+    if (itemType === 'message') {
+        const content = item.content;
+        const parts = Array.isArray(content)
+            ? content.map(buildInputPart)
+            : [{ type: 'text', content: content ?? '' }];
+        return { role: item.role ?? 'user', parts };
+    }
+    if (itemType === 'function_call') {
+        return {
+            role: 'assistant',
+            parts: [
+                {
+                    type: 'tool_call',
+                    name: item.name ?? null,
+                    id: item.id ?? item.call_id ?? null,
+                    arguments: parseArguments(item.arguments),
+                },
+            ],
+        };
+    }
+    if (itemType === 'function_call_output') {
+        return {
+            role: 'tool',
+            parts: [
+                { type: 'tool_call_response', id: item.call_id ?? null, response: item.output ?? '' },
+            ],
+        };
+    }
+    return null;
+}
+/** The request's `instructions` + `input` as OTel input messages. */
+function buildResponsesInputMessages(params) {
+    const messages = [];
+    if (params.instructions) {
+        messages.push({
+            role: 'system',
+            parts: [{ type: 'text', content: params.instructions }],
+        });
+    }
+    const input = params.input;
+    if (typeof input === 'string') {
+        messages.push({ role: 'user', parts: [{ type: 'text', content: input }] });
+    }
+    else if (Array.isArray(input)) {
+        for (const item of input) {
+            const message = buildInputMessage(item);
+            if (message)
+                messages.push(message);
+        }
+    }
+    return messages;
+}
+/** The request's function tools, in the flat shape the Responses API takes. */
+function buildResponsesToolDefinitions(params) {
+    const tools = Array.isArray(params.tools) ? params.tools : [];
+    const definitions = [];
+    for (const tool of tools) {
+        if (!isJsonObject(tool) || tool.type !== 'function')
+            continue;
+        const definition = { type: 'function' };
+        if (tool.name)
+            definition.name = tool.name;
+        if (tool.description)
+            definition.description = tool.description;
+        if (tool.parameters)
+            definition.parameters = tool.parameters;
+        definitions.push(definition);
+    }
+    return definitions;
+}
+/** The response's `status` as an OTel finish reason. */
+function deriveFinishReason(response) {
+    const status = response.status;
+    if (!status)
+        return '';
+    if (status === 'completed') {
+        const output = Array.isArray(response.output) ? response.output : [];
+        const callsATool = output.some((block) => isJsonObject(block) && TOOL_CALL_BLOCK_TYPES.includes(String(block.type)));
+        return callsATool ? 'tool_call' : 'stop';
+    }
+    if (status === 'incomplete') {
+        const reason = isJsonObject(response.incomplete_details)
+            ? response.incomplete_details.reason
+            : null;
+        return reason === 'content_filter' ? 'content_filter' : 'length';
+    }
+    if (status === 'failed' || status === 'cancelled')
+        return 'error';
+    return '';
+}
+/** The answer's text, from `output_text` or by joining the output text blocks. */
+function readOutputText(response) {
+    if (typeof response.output_text === 'string')
+        return response.output_text;
+    const output = Array.isArray(response.output) ? response.output : [];
+    const texts = [];
+    for (const block of output) {
+        if (!isJsonObject(block) || block.type !== 'message')
+            continue;
+        const content = Array.isArray(block.content) ? block.content : [];
+        for (const part of content) {
+            if (isJsonObject(part) && part.type === 'output_text' && typeof part.text === 'string') {
+                texts.push(part.text);
+            }
+        }
+    }
+    return texts.join('');
+}
+/** The response's text, tool calls and reasoning summaries as one OTel message. */
+function buildResponsesOutputMessages(response) {
+    const parts = [];
+    const outputText = readOutputText(response);
+    if (outputText) {
+        parts.push({ type: 'text', content: outputText });
+    }
+    const output = Array.isArray(response.output) ? response.output : [];
+    for (const block of output) {
+        if (!isJsonObject(block))
+            continue;
+        if (block.type === 'function_call') {
+            parts.push({
+                type: 'tool_call',
+                name: block.name ?? null,
+                id: block.id ?? null,
+                arguments: parseArguments(block.arguments),
+            });
+        }
+        else if (block.type === 'reasoning') {
+            const summary = block.summary;
+            if (summary != null && !(Array.isArray(summary) && summary.length === 0)) {
+                parts.push({
+                    type: 'reasoning',
+                    content: typeof summary === 'string' ? summary : JSON.stringify(summary),
+                });
+            }
+        }
+    }
+    if (!parts.length)
+        return [];
+    return [{ role: 'assistant', parts, finish_reason: deriveFinishReason(response) }];
+}
+function setUsageAttributes(span, usage) {
+    if (typeof usage.input_tokens === 'number') {
+        span.setAttribute(INPUT_TOKENS_ATTR, usage.input_tokens);
+    }
+    if (typeof usage.output_tokens === 'number') {
+        span.setAttribute(OUTPUT_TOKENS_ATTR, usage.output_tokens);
+    }
+    if (typeof usage.total_tokens === 'number') {
+        span.setAttribute(TOTAL_TOKENS_ATTR, usage.total_tokens);
+    }
+    const inputDetails = isJsonObject(usage.input_tokens_details) ? usage.input_tokens_details : {};
+    if (inputDetails.cached_tokens) {
+        span.setAttribute(CACHE_READ_INPUT_TOKENS_ATTR, inputDetails.cached_tokens);
+    }
+    if (inputDetails.cache_write_tokens) {
+        span.setAttribute(CACHE_CREATION_INPUT_TOKENS_ATTR, inputDetails.cache_write_tokens);
+    }
+    const outputDetails = isJsonObject(usage.output_tokens_details)
+        ? usage.output_tokens_details
+        : {};
+    if (outputDetails.reasoning_tokens) {
+        span.setAttribute(REASONING_TOKENS_ATTR, outputDetails.reasoning_tokens);
+    }
+}
+/** How many document searches a Responses answer is billed for, from xAI's
+ * `usage.server_side_tool_usage_details.document_search_calls`, or null when the
+ * usage reports none, e.g. `{server_side_tool_usage_details:
+ * {document_search_calls: 1}}` -> 1. */
+function readBilledDocumentSearchCount(usage) {
+    const count = usage?.server_side_tool_usage_details?.document_search_calls;
+    return typeof count === 'number' && count > 0 ? count : null;
+}
+/** Stamp everything the response carries: ids, usage, reasoning, messages. */
+function setResponseAttributes(span, response, sendPrompts) {
+    if (!isJsonObject(response) || !span.isRecording())
+        return;
+    if (response.id)
+        span.setAttribute(RESPONSE_ID_ATTR, String(response.id));
+    if (response.model)
+        span.setAttribute(RESPONSE_MODEL_ATTR, String(response.model));
+    if (response.service_tier) {
+        span.setAttribute(RESPONSE_SERVICE_TIER_ATTR, String(response.service_tier));
+    }
+    if (isJsonObject(response.usage))
+        setUsageAttributes(span, response.usage);
+    const documentSearchCount = readBilledDocumentSearchCount(response.usage);
+    if (documentSearchCount !== null) {
+        span.setAttribute(DOCUMENT_SEARCH_REQUESTS_ATTR, documentSearchCount);
+    }
+    if (isJsonObject(response.reasoning) && response.reasoning.effort) {
+        span.setAttribute(RESPONSE_REASONING_EFFORT_ATTR, String(response.reasoning.effort));
+    }
+    const finishReason = deriveFinishReason(response);
+    if (finishReason)
+        span.setAttribute(FINISH_REASONS_ATTR, [finishReason]);
+    // Stamped whatever `sendPrompts` is: the span processor strips the searches
+    // and the citations as content, and keeps the billed count, which is not.
+    (0, get_web_search_telemetry_1.setResponsesWebSearchAnswerAttributes)(span, response);
+    if (sendPrompts) {
+        span.setAttribute(OUTPUT_MESSAGES_ATTR, JSON.stringify(buildResponsesOutputMessages(response)));
+    }
+}
+/** Stamp what only the request knows: its messages, tools and reasoning ask. */
+function setRequestAttributes(span, params, sendPrompts) {
+    if (!isJsonObject(params) || !span.isRecording())
+        return;
+    if (isJsonObject(params.reasoning)) {
+        if (params.reasoning.effort) {
+            span.setAttribute(REQUEST_REASONING_EFFORT_ATTR, String(params.reasoning.effort));
+        }
+        if (params.reasoning.summary) {
+            span.setAttribute(REQUEST_REASONING_SUMMARY_ATTR, String(params.reasoning.summary));
+        }
+    }
+    (0, get_web_search_telemetry_1.setResponsesWebSearchRequestAttributes)(span, params);
+    if (!sendPrompts)
+        return;
+    span.setAttribute(INPUT_MESSAGES_ATTR, JSON.stringify(buildResponsesInputMessages(params)));
+    const definitions = buildResponsesToolDefinitions(params);
+    if (definitions.length) {
+        span.setAttribute(TOOL_DEFINITIONS_ATTR, JSON.stringify(definitions));
+    }
+}
+/**
+ * The response a streamed call built, assembled from its events.
+ *
+ * Every Responses stream event carries the whole response object under
+ * `response` on its lifecycle events (`response.created`,
+ * `response.completed`, `response.incomplete`, `response.failed`), so the
+ * terminal one already holds the output blocks and the usage. Keeping the last
+ * one seen is enough: no per-delta accumulation.
+ */
+function readEventResponse(event) {
+    if (!isJsonObject(event))
+        return null;
+    return isJsonObject(event.response) ? event.response : null;
+}
+/**
+ * Upstream's own content-capture gate, so a span carries message content on
+ * exactly the calls its spans would. Falls through to capturing when the gate
+ * cannot be read: the span processor strips content when capture is off, so
+ * this can never leak.
+ */
+function shouldSendPrompts(instrumentation) {
+    try {
+        if (typeof instrumentation._shouldSendPrompts === 'function') {
+            return instrumentation._shouldSendPrompts();
+        }
+    }
+    catch {
+        // An instrumentor whose gate threw: treat content as capturable.
+    }
+    return true;
+}
+/**
+ * Wrap a Responses stream's iterator so its events pass through untouched while
+ * the last response object seen is stamped on the span, which ends with the
+ * iteration.
+ *
+ * Mutates `stream` in place and returns it, so the caller still hands the app
+ * the exact object the openai client returned.
+ */
+function recordResponsesStreamEvents(stream, span, sendPrompts) {
+    if (!stream || typeof stream[Symbol.asyncIterator] !== 'function') {
+        span.end();
+        return stream;
+    }
+    const originalIterator = stream[Symbol.asyncIterator].bind(stream);
+    stream[Symbol.asyncIterator] = async function* recordEvents() {
+        let lastResponse = null;
+        try {
+            for await (const event of originalIterator()) {
+                const response = readEventResponse(event);
+                if (response)
+                    lastResponse = response;
+                yield event;
+            }
+        }
+        catch (error) {
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error?.message ?? String(error) });
+            span.recordException(error);
+            throw error;
+        }
+        finally {
+            try {
+                if (lastResponse)
+                    setResponseAttributes(span, lastResponse, sendPrompts);
+            }
+            catch {
+                // Never let an enrichment failure swallow the caller's stream.
+            }
+            span.end();
+        }
+    };
+    return stream;
+}
+function traceStreamedCall({ instrumentation, openaiCreate, client, params, rest, }) {
+    const span = startStreamedSpan(instrumentation, params, client);
+    if (!span)
+        return openaiCreate.call(client, params, ...rest);
+    const sendPrompts = shouldSendPrompts(instrumentation);
+    const streamPromise = api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), () => openaiCreate.call(client, params, ...rest));
+    // Registered before the caller's own handler, so the iterator is already
+    // wrapped by the time they iterate. The returned promise is upstream's own,
+    // so the caller still gets the exact object the openai client returns.
+    Promise.resolve(streamPromise).then((stream) => {
+        try {
+            recordResponsesStreamEvents(stream, span, sendPrompts);
+        }
+        catch {
+            // A telemetry failure must never reject this handler's promise: nothing
+            // handles it, and Node terminates the app on an unhandled rejection.
+            span.end();
+        }
+    }, (error) => {
+        span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error?.message ?? String(error) });
+        span.recordException(error);
+        span.end();
+    });
+    return streamPromise;
+}
+// Reuse upstream's request-attribute logic (and, through the patch above, our
+// own) so a streamed span carries exactly what a non-streamed one carries.
+function startStreamedSpan(instrumentation, params, client) {
+    try {
+        if (typeof instrumentation.startSpan === 'function') {
+            return instrumentation.startSpan({ type: RESPONSES_TYPE, params, client });
+        }
+        const span = api_1.trace.getTracer(TRACER_NAME).startSpan(`chat ${params && params.model}`);
+        setRequestAttributes(span, params, shouldSendPrompts(instrumentation));
+        return span;
+    }
+    catch {
+        return null;
+    }
+}
+class OpenAIResponsesInstrumentor {
+    // [owner, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    // No-op (and never throws) if the instrumentor's internals or the openai
+    // client have changed shape: the worst case is the upstream telemetry,
+    // never a crash.
+    instrument(instrumentation) {
+        this._patchRequestSide(instrumentation);
+        this._patchResponseSide(instrumentation);
+        this._takeOverStreamedCalls(instrumentation);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+    // Rebuild the input messages and tool definitions upstream stamps as one
+    // stringified text part. Runs for a non-streamed call (upstream calls
+    // startSpan) and for a streamed one (the takeover below calls it).
+    _patchRequestSide(instrumentation) {
+        const original = instrumentation && instrumentation.startSpan;
+        if (typeof original !== 'function')
+            return;
+        instrumentation.startSpan = function startSpanWithResponsesShape(args) {
+            const span = original.call(this, args);
+            try {
+                if (args && args.type === RESPONSES_TYPE) {
+                    setRequestAttributes(span, args.params, shouldSendPrompts(instrumentation));
+                }
+            }
+            catch {
+                // Never break span creation over an enrichment failure.
+            }
+            return span;
+        };
+        this._patched.push([instrumentation, 'startSpan', original]);
+    }
+    // Own the response side of a Responses call and end its span here. Upstream's
+    // handler stamps the same two attributes from the answer's text alone, so
+    // delegating to it would replace a tool call with an empty text part and
+    // "stop", and it ends the span immediately after, leaving nowhere to repair
+    // them. Every other call type is handed straight to it.
+    _patchResponseSide(instrumentation) {
+        const original = instrumentation && instrumentation._endSpan;
+        if (typeof original !== 'function')
+            return;
+        instrumentation._endSpan = function endSpanWithResponsesShape(args) {
+            if (!args || args.type !== RESPONSES_TYPE || !args.span) {
+                return original.call(this, args);
+            }
+            try {
+                setResponseAttributes(args.span, args.result, shouldSendPrompts(instrumentation));
+            }
+            catch {
+                // Never break span finalization over an enrichment failure.
+            }
+            args.span.end();
+        };
+        this._patched.push([instrumentation, '_endSpan', original]);
+    }
+    /**
+     * Own the streamed branch upstream leaves uninstrumented.
+     *
+     * Our wrapper sits outside upstream's, so a non-streamed call is delegated
+     * straight to it. A streamed call instead calls the function upstream wrapped
+     * (shimmer's `__original`), so only one span is ever created, and ends that
+     * span once the stream's events are consumed.
+     */
+    _takeOverStreamedCalls(instrumentation) {
+        let Responses;
+        try {
+            // The package entry, not the `resources/responses/responses` submodule:
+            // upstream's hook is registered on the package name, so requiring it here
+            // is what runs its patch when the app has not imported `openai` yet. Were
+            // we to patch first, our wrapper would sit under upstream's instead of
+            // outside it, and a streamed call would get one span from each.
+            Responses = require('openai').OpenAI?.Responses;
+        }
+        catch {
+            // No openai client installed: nothing to take over.
+            return;
+        }
+        const owner = Responses && Responses.prototype;
+        const upstreamWrapper = owner && owner.create;
+        if (typeof upstreamWrapper !== 'function')
+            return;
+        // Set by shimmer when upstream wrapped `create`; absent when it did not, in
+        // which case its wrapper IS the original and there is no span to avoid.
+        const openaiCreate = upstreamWrapper.__original || upstreamWrapper;
+        owner.create = function createWithStreamedResponses(params, ...rest) {
+            if (!params || !params.stream) {
+                return upstreamWrapper.call(this, params, ...rest);
+            }
+            return traceStreamedCall({
+                instrumentation,
+                openaiCreate,
+                client: this,
+                params,
+                rest,
+            });
+        };
+        this._patched.push([owner, 'create', upstreamWrapper]);
+    }
+}
+exports.OpenAIResponsesInstrumentor = OpenAIResponsesInstrumentor;