monora-ai 2.0.0 → 2.1.3

package/dist/integrations/openai.js

@@ -21,8 +21,18 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchOpenAI = patchOpenAI;
+exports.wrapChatCompletions = wrapChatCompletions;
+exports.wrapCompletions = wrapCompletions;
+exports.wrapEmbeddings = wrapEmbeddings;
+exports.wrapResponsesStreamMethod = wrapResponsesStreamMethod;
+exports.wrapResponses = wrapResponses;
 const runtime_1 = require("../runtime");
+const data_handling_1 = require("../data_handling");
+const policy_1 = require("../policy");
+const quotas_1 = require("../quotas");
+const context_1 = require("../context");
 const lineage_1 = require("../lineage");
+const governance_1 = require("./governance");
 /**
  * Patch an OpenAI client to automatically trace all API calls.
  */
@@ -43,6 +53,20 @@ function patchOpenAI(client, options = {}) {
         const originalCreate = client.embeddings.create.bind(client.embeddings);
         client.embeddings.create = wrapEmbeddings(originalCreate, dataClassification, purpose, reason);
     }
+    // Patch responses API (OpenAI Responses)
+    if (client.responses) {
+        const originalCreate = client.responses.create.bind(client.responses);
+        client.responses.create = wrapResponses(originalCreate, dataClassification, purpose, reason);
+        if (client.responses.stream) {
+            const originalStream = client.responses.stream.bind(client.responses);
+            client.responses.stream = wrapResponsesStreamMethod(originalStream, dataClassification, purpose, reason);
+        }
+    }
+}
+function isGovernanceError(error) {
+    return (error instanceof data_handling_1.DataHandlingViolation ||
+        error instanceof policy_1.PolicyViolation ||
+        error instanceof quotas_1.QuotaExceededError);
 }
 function wrapChatCompletions(originalFn, dataClassification, purpose, reason) {
     return async function wrappedChatCompletions(...args) {
@@ -50,28 +74,49 @@ function wrapChatCompletions(originalFn, dataClassification, purpose, reason) {
         const model = kwargs.model || 'unknown';
         const messages = kwargs.messages || [];
         const isStreaming = kwargs.stream === true;
-        const state = (0, runtime_1.ensureState)();
-        const startEvent = state.eventBuilder.build('llm_call', {
+        const requestPayload = Object.keys(kwargs).length > 0 ? kwargs : { args };
+        const { state, trace } = (0, governance_1.preflightLlmCall)({
             model,
-            provider: 'openai',
-            api: 'chat.completions',
-            num_messages: messages.length,
-            messages: messages.slice(0, 10),
-            stream: isStreaming,
-            temperature: kwargs.temperature,
-            max_tokens: kwargs.max_tokens,
-            top_p: kwargs.top_p,
-        }, {
+            requestPayload,
             dataClassification,
             purpose,
             reason,
+            provider: 'openai',
+            spanName: 'llm_call:openai.chat.completions',
+        });
+        const startEvent = (0, context_1.runInContext)(trace.context, () => {
+            const event = state.eventBuilder.build('llm_call', {
+                model,
+                provider: 'openai',
+                api: 'chat.completions',
+                num_messages: messages.length,
+                messages: messages.slice(0, 10),
+                stream: isStreaming,
+                temperature: kwargs.temperature,
+                max_tokens: kwargs.max_tokens,
+                top_p: kwargs.top_p,
+                status: 'started',
+            }, {
+                dataClassification,
+                purpose,
+                reason,
+            });
+            (0, runtime_1.emitEvent)(event);
+            return event;
         });
-        (0, runtime_1.emitEvent)(startEvent);
         (0, lineage_1.setCurrentEvent)(startEvent.event_id);
         try {
-            const response = await originalFn(...args);
+            const response = await originalFn.apply(this, args);
             if (isStreaming) {
-                return wrapStreamingResponse(response, model, startEvent.event_id, dataClassification, purpose, state);
+                return wrapStreamingResponse(response, {
+                    model,
+                    parentEventId: startEvent.event_id,
+                    dataClassification,
+                    purpose,
+                    reason,
+                    state,
+                    trace,
+                });
             }
             // Non-streaming response
             const completionData = {
@@ -94,33 +139,65 @@ function wrapChatCompletions(originalFn, dataClassification, purpose, reason) {
                     },
                 }));
             }
-            const completionEvent = state.eventBuilder.build('llm_call', completionData, {
+            (0, context_1.runInContext)(trace.context, () => {
+                const completionEvent = state.eventBuilder.build('llm_call', {
+                    ...completionData,
+                    status: 'success',
+                }, {
+                    dataClassification,
+                    purpose,
+                    parentEventId: startEvent.event_id,
+                });
+                (0, runtime_1.emitEvent)(completionEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state,
+                trace,
+                model,
+                response,
                 dataClassification,
                 purpose,
-                parentEventId: startEvent.event_id,
+                reason,
             });
-            (0, runtime_1.emitEvent)(completionEvent);
             return response;
         }
         catch (error) {
-            const errorEvent = state.eventBuilder.build('llm_call', {
+            if (isGovernanceError(error)) {
+                throw error;
+            }
+            (0, context_1.runInContext)(trace.context, () => {
+                const errorEvent = state.eventBuilder.build('llm_call', {
+                    model,
+                    error: error.message || String(error),
+                    error_type: error.constructor?.name || 'Error',
+                    status: 'error',
+                }, {
+                    dataClassification,
+                    purpose,
+                    parentEventId: startEvent.event_id,
+                });
+                (0, runtime_1.emitEvent)(errorEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state,
+                trace,
                 model,
-                error: error.message || String(error),
-                error_type: error.constructor?.name || 'Error',
-            }, {
+                response: null,
                 dataClassification,
                 purpose,
-                parentEventId: startEvent.event_id,
+                reason,
+                error: true,
             });
-            (0, runtime_1.emitEvent)(errorEvent);
             throw error;
         }
     };
 }
-async function* wrapStreamingResponse(stream, model, parentEventId, dataClassification, purpose, state) {
+async function* wrapStreamingResponse(stream, options) {
     let accumulatedContent = '';
     let finishReason = null;
     let role = null;
+    let usage = null;
+    let error = null;
     try {
         for await (const chunk of stream) {
             // Track content from streaming chunks
@@ -136,24 +213,306 @@ async function* wrapStreamingResponse(stream, model, parentEventId, dataClassifi
                     finishReason = choice.finish_reason;
                 }
             }
+            if (chunk.usage) {
+                usage = chunk.usage;
+            }
             yield chunk;
         }
     }
+    catch (err) {
+        error = err;
+        throw err;
+    }
     finally {
-        // Emit completion event when stream ends
-        const completionEvent = state.eventBuilder.build('llm_call', {
-            model,
-            stream_complete: true,
-            content: accumulatedContent.slice(0, 500) || null,
-            content_length: accumulatedContent.length,
-            finish_reason: finishReason,
-            role,
-        }, {
-            dataClassification,
-            purpose,
-            parentEventId,
+        const responseStub = usage ? { usage } : null;
+        if (error) {
+            (0, context_1.runInContext)(options.trace.context, () => {
+                const errorEvent = options.state.eventBuilder.build('llm_call', {
+                    model: options.model,
+                    error: error.message || String(error),
+                    error_type: error.constructor?.name || 'Error',
+                    status: 'error',
+                }, {
+                    dataClassification: options.dataClassification,
+                    purpose: options.purpose,
+                    parentEventId: options.parentEventId,
+                });
+                (0, runtime_1.emitEvent)(errorEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state: options.state,
+                trace: options.trace,
+                model: options.model,
+                response: null,
+                dataClassification: options.dataClassification,
+                purpose: options.purpose,
+                reason: options.reason,
+                error: true,
+            });
+        }
+        if (!error) {
+            // Emit completion event when stream ends
+            (0, context_1.runInContext)(options.trace.context, () => {
+                const completionEvent = options.state.eventBuilder.build('llm_call', {
+                    model: options.model,
+                    stream_complete: true,
+                    content: accumulatedContent.slice(0, 500) || null,
+                    content_length: accumulatedContent.length,
+                    finish_reason: finishReason,
+                    role,
+                    usage: usage || undefined,
+                    status: 'success',
+                }, {
+                    dataClassification: options.dataClassification,
+                    purpose: options.purpose,
+                    parentEventId: options.parentEventId,
+                });
+                (0, runtime_1.emitEvent)(completionEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state: options.state,
+                trace: options.trace,
+                model: options.model,
+                response: responseStub,
+                dataClassification: options.dataClassification,
+                purpose: options.purpose,
+                reason: options.reason,
+            });
+        }
+    }
+}
+function formatInputPreview(input) {
+    if (typeof input === 'string') {
+        return input.slice(0, 500);
+    }
+    try {
+        return JSON.stringify(input).slice(0, 500);
+    }
+    catch {
+        return String(input).slice(0, 500);
+    }
+}
+function extractResponseText(chunk) {
+    if (!chunk) {
+        return null;
+    }
+    if (typeof chunk === 'string') {
+        return chunk;
+    }
+    if (typeof chunk.output_text === 'string') {
+        return chunk.output_text;
+    }
+    if (typeof chunk.text === 'string') {
+        return chunk.text;
+    }
+    if (typeof chunk.content === 'string') {
+        return chunk.content;
+    }
+    if (typeof chunk.delta === 'string') {
+        return chunk.delta;
+    }
+    if (chunk.type === 'response.output_text.delta' && typeof chunk.delta === 'string') {
+        return chunk.delta;
+    }
+    const response = chunk.response ?? chunk.data ?? null;
+    if (response) {
+        if (typeof response.output_text === 'string') {
+            return response.output_text;
+        }
+        if (typeof response.text === 'string') {
+            return response.text;
+        }
+        if (typeof response.content === 'string') {
+            return response.content;
+        }
+    }
+    return null;
+}
+function extractResponseUsage(chunk) {
+    if (!chunk) {
+        return null;
+    }
+    const usage = chunk.usage ?? chunk.response?.usage ?? chunk.data?.usage;
+    if (usage && typeof usage === 'object') {
+        return usage;
+    }
+    return null;
+}
+async function* wrapResponsesStream(stream, options) {
+    let accumulatedContent = '';
+    let usage = null;
+    let error = null;
+    try {
+        for await (const chunk of stream) {
+            const text = extractResponseText(chunk);
+            if (text) {
+                accumulatedContent += text;
+            }
+            const chunkUsage = extractResponseUsage(chunk);
+            if (chunkUsage) {
+                usage = chunkUsage;
+            }
+            yield chunk;
+        }
+    }
+    catch (err) {
+        error = err;
+        throw err;
+    }
+    finally {
+        const responseStub = usage ? { usage } : null;
+        if (error) {
+            (0, context_1.runInContext)(options.trace.context, () => {
+                const errorEvent = options.state.eventBuilder.build('llm_call', {
+                    model: options.model,
+                    error: error.message || String(error),
+                    error_type: error.constructor?.name || 'Error',
+                    status: 'error',
+                }, {
+                    dataClassification: options.dataClassification,
+                    purpose: options.purpose,
+                    parentEventId: options.parentEventId,
+                });
+                (0, runtime_1.emitEvent)(errorEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state: options.state,
+                trace: options.trace,
+                model: options.model,
+                response: null,
+                dataClassification: options.dataClassification,
+                purpose: options.purpose,
+                reason: options.reason,
+                error: true,
+            });
+            throw error;
+        }
+        (0, context_1.runInContext)(options.trace.context, () => {
+            const completionEvent = options.state.eventBuilder.build('llm_call', {
+                model: options.model,
+                stream_complete: true,
+                content: accumulatedContent.slice(0, 500) || null,
+                content_length: accumulatedContent.length,
+                usage: usage || undefined,
+                status: 'success',
+            }, {
+                dataClassification: options.dataClassification,
+                purpose: options.purpose,
+                parentEventId: options.parentEventId,
+            });
+            (0, runtime_1.emitEvent)(completionEvent);
         });
-        (0, runtime_1.emitEvent)(completionEvent);
+        await (0, governance_1.postflightLlmCall)({
+            state: options.state,
+            trace: options.trace,
+            model: options.model,
+            response: responseStub,
+            dataClassification: options.dataClassification,
+            purpose: options.purpose,
+            reason: options.reason,
+        });
+    }
+}
+class ResponsesStreamManagerWrapper {
+    constructor(streamManager, model, parentEventId, dataClassification, purpose, reason, state, trace) {
+        this.accumulatedContent = '';
+        this.usage = null;
+        this.streamManager = streamManager;
+        this.model = model;
+        this.parentEventId = parentEventId;
+        this.dataClassification = dataClassification;
+        this.purpose = purpose;
+        this.reason = reason;
+        this.state = state;
+        this.trace = trace;
+    }
+    async *[Symbol.asyncIterator]() {
+        let error = null;
+        try {
+            for await (const chunk of this.streamManager) {
+                const text = extractResponseText(chunk);
+                if (text) {
+                    this.accumulatedContent += text;
+                }
+                const chunkUsage = extractResponseUsage(chunk);
+                if (chunkUsage) {
+                    this.usage = chunkUsage;
+                }
+                yield chunk;
+            }
+        }
+        catch (err) {
+            error = err;
+            throw err;
+        }
+        finally {
+            await this.emitCompletion(error);
+        }
+    }
+    async emitCompletion(error) {
+        if (error) {
+            (0, context_1.runInContext)(this.trace.context, () => {
+                const errorEvent = this.state.eventBuilder.build('llm_call', {
+                    model: this.model,
+                    error: error.message || String(error),
+                    error_type: error.constructor?.name || 'Error',
+                    status: 'error',
+                }, {
+                    dataClassification: this.dataClassification,
+                    purpose: this.purpose,
+                    parentEventId: this.parentEventId,
+                });
+                (0, runtime_1.emitEvent)(errorEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state: this.state,
+                trace: this.trace,
+                model: this.model,
+                response: null,
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+                reason: this.reason,
+                error: true,
+            });
+            return;
+        }
+        (0, context_1.runInContext)(this.trace.context, () => {
+            const completionEvent = this.state.eventBuilder.build('llm_call', {
+                model: this.model,
+                stream_complete: true,
+                content: this.accumulatedContent.slice(0, 500) || null,
+                content_length: this.accumulatedContent.length,
+                usage: this.usage || undefined,
+                status: 'success',
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+                parentEventId: this.parentEventId,
+            });
+            (0, runtime_1.emitEvent)(completionEvent);
+        });
+        await (0, governance_1.postflightLlmCall)({
+            state: this.state,
+            trace: this.trace,
+            model: this.model,
+            response: this.usage ? { usage: this.usage } : null,
+            dataClassification: this.dataClassification,
+            purpose: this.purpose,
+            reason: this.reason,
+        });
+    }
+    on(event, callback) {
+        this.streamManager.on?.(event, callback);
+        return this;
+    }
+    get controller() {
+        return this.streamManager.controller;
+    }
+    async finalResponse() {
+        return this.streamManager.finalResponse?.();
+    }
+    async getFinalResponse() {
+        return this.streamManager.getFinalResponse?.();
     }
 }
 function wrapCompletions(originalFn, dataClassification, purpose, reason) {
@@ -161,23 +520,36 @@ function wrapCompletions(originalFn, dataClassification, purpose, reason) {
         const kwargs = args[0] || {};
         const model = kwargs.model || 'unknown';
         const prompt = kwargs.prompt || '';
-        const state = (0, runtime_1.ensureState)();
-        const startEvent = state.eventBuilder.build('llm_call', {
+        const requestPayload = Object.keys(kwargs).length > 0 ? kwargs : { args };
+        const { state, trace } = (0, governance_1.preflightLlmCall)({
             model,
-            provider: 'openai',
-            api: 'completions',
-            prompt: String(prompt).slice(0, 1000),
-            max_tokens: kwargs.max_tokens,
-            temperature: kwargs.temperature,
-        }, {
+            requestPayload,
             dataClassification,
             purpose,
             reason,
+            provider: 'openai',
+            spanName: 'llm_call:openai.completions',
+        });
+        const startEvent = (0, context_1.runInContext)(trace.context, () => {
+            const event = state.eventBuilder.build('llm_call', {
+                model,
+                provider: 'openai',
+                api: 'completions',
+                prompt: String(prompt).slice(0, 1000),
+                max_tokens: kwargs.max_tokens,
+                temperature: kwargs.temperature,
+                status: 'started',
+            }, {
+                dataClassification,
+                purpose,
+                reason,
+            });
+            (0, runtime_1.emitEvent)(event);
+            return event;
         });
-        (0, runtime_1.emitEvent)(startEvent);
         (0, lineage_1.setCurrentEvent)(startEvent.event_id);
         try {
-            const response = await originalFn(...args);
+            const response = await originalFn.apply(this, args);
             const completionData = {
                 model: response.model || model,
             };
@@ -195,25 +567,55 @@ function wrapCompletions(originalFn, dataClassification, purpose, reason) {
                     finish_reason: choice.finish_reason,
                 }));
             }
-            const completionEvent = state.eventBuilder.build('llm_call', completionData, {
+            (0, context_1.runInContext)(trace.context, () => {
+                const completionEvent = state.eventBuilder.build('llm_call', {
+                    ...completionData,
+                    status: 'success',
+                }, {
+                    dataClassification,
+                    purpose,
+                    parentEventId: startEvent.event_id,
+                });
+                (0, runtime_1.emitEvent)(completionEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state,
+                trace,
+                model,
+                response,
                 dataClassification,
                 purpose,
-                parentEventId: startEvent.event_id,
+                reason,
             });
-            (0, runtime_1.emitEvent)(completionEvent);
             return response;
         }
         catch (error) {
-            const errorEvent = state.eventBuilder.build('llm_call', {
+            if (isGovernanceError(error)) {
+                throw error;
+            }
+            (0, context_1.runInContext)(trace.context, () => {
+                const errorEvent = state.eventBuilder.build('llm_call', {
+                    model,
+                    error: error.message || String(error),
+                    error_type: error.constructor?.name || 'Error',
+                    status: 'error',
+                }, {
+                    dataClassification,
+                    purpose,
+                    parentEventId: startEvent.event_id,
+                });
+                (0, runtime_1.emitEvent)(errorEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state,
+                trace,
                 model,
-                error: error.message || String(error),
-                error_type: error.constructor?.name || 'Error',
-            }, {
+                response: null,
                 dataClassification,
                 purpose,
-                parentEventId: startEvent.event_id,
+                reason,
+                error: true,
             });
-            (0, runtime_1.emitEvent)(errorEvent);
             throw error;
         }
     };
@@ -227,22 +629,35 @@ function wrapEmbeddings(originalFn, dataClassification, purpose, reason) {
         const inputPreview = Array.isArray(input)
             ? input.slice(0, 3)
             : [String(input).slice(0, 500)];
-        const state = (0, runtime_1.ensureState)();
-        const startEvent = state.eventBuilder.build('llm_call', {
+        const requestPayload = Object.keys(kwargs).length > 0 ? kwargs : { args };
+        const { state, trace } = (0, governance_1.preflightLlmCall)({
             model,
-            provider: 'openai',
-            api: 'embeddings',
-            num_inputs: numInputs,
-            input_preview: inputPreview,
-        }, {
+            requestPayload,
             dataClassification,
             purpose,
             reason,
+            provider: 'openai',
+            spanName: 'llm_call:openai.embeddings',
+        });
+        const startEvent = (0, context_1.runInContext)(trace.context, () => {
+            const event = state.eventBuilder.build('llm_call', {
+                model,
+                provider: 'openai',
+                api: 'embeddings',
+                num_inputs: numInputs,
+                input_preview: inputPreview,
+                status: 'started',
+            }, {
+                dataClassification,
+                purpose,
+                reason,
+            });
+            (0, runtime_1.emitEvent)(event);
+            return event;
         });
-        (0, runtime_1.emitEvent)(startEvent);
         (0, lineage_1.setCurrentEvent)(startEvent.event_id);
         try {
-            const response = await originalFn(...args);
+            const response = await originalFn.apply(this, args);
             const completionData = {
                 model: response.model || model,
                 num_embeddings: response.data?.length || 0,
@@ -253,25 +668,210 @@ function wrapEmbeddings(originalFn, dataClassification, purpose, reason) {
                     total_tokens: response.usage.total_tokens,
                 };
             }
-            const completionEvent = state.eventBuilder.build('llm_call', completionData, {
+            (0, context_1.runInContext)(trace.context, () => {
+                const completionEvent = state.eventBuilder.build('llm_call', {
+                    ...completionData,
+                    status: 'success',
+                }, {
+                    dataClassification,
+                    purpose,
+                    parentEventId: startEvent.event_id,
+                });
+                (0, runtime_1.emitEvent)(completionEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state,
+                trace,
+                model,
+                response,
                 dataClassification,
                 purpose,
-                parentEventId: startEvent.event_id,
+                reason,
             });
-            (0, runtime_1.emitEvent)(completionEvent);
             return response;
         }
         catch (error) {
-            const errorEvent = state.eventBuilder.build('llm_call', {
+            if (isGovernanceError(error)) {
+                throw error;
+            }
+            (0, context_1.runInContext)(trace.context, () => {
+                const errorEvent = state.eventBuilder.build('llm_call', {
+                    model,
+                    error: error.message || String(error),
+                    error_type: error.constructor?.name || 'Error',
+                    status: 'error',
+                }, {
+                    dataClassification,
+                    purpose,
+                    parentEventId: startEvent.event_id,
+                });
+                (0, runtime_1.emitEvent)(errorEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state,
+                trace,
+                model,
+                response: null,
+                dataClassification,
+                purpose,
+                reason,
+                error: true,
+            });
+            throw error;
+        }
+    };
+}
+function wrapResponsesStreamMethod(originalFn, dataClassification, purpose, reason) {
+    return function wrappedResponsesStream(...args) {
+        const kwargs = args[0] || {};
+        const model = kwargs.model || 'unknown';
+        const input = kwargs.input ?? '';
+        const numInputs = Array.isArray(input) ? input.length : 1;
+        const inputPreview = Array.isArray(input)
+            ? input.slice(0, 3).map((item) => formatInputPreview(item))
+            : [formatInputPreview(input)];
+        const requestPayload = Object.keys(kwargs).length > 0 ? kwargs : { args };
+        const { state, trace } = (0, governance_1.preflightLlmCall)({
+            model,
+            requestPayload,
+            dataClassification,
+            purpose,
+            reason,
+            provider: 'openai',
+            spanName: 'llm_call:openai.responses.stream',
+        });
+        const startEvent = (0, context_1.runInContext)(trace.context, () => {
+            const event = state.eventBuilder.build('llm_call', {
                 model,
-                error: error.message || String(error),
-                error_type: error.constructor?.name || 'Error',
+                provider: 'openai',
+                api: 'responses.stream',
+                num_inputs: numInputs,
+                input_preview: inputPreview,
+                stream: true,
+                status: 'started',
             }, {
                 dataClassification,
                 purpose,
-                parentEventId: startEvent.event_id,
+                reason,
+            });
+            (0, runtime_1.emitEvent)(event);
+            return event;
+        });
+        (0, lineage_1.setCurrentEvent)(startEvent.event_id);
+        const streamManager = originalFn.apply(this, args);
+        return new ResponsesStreamManagerWrapper(streamManager, model, startEvent.event_id, dataClassification, purpose, reason, state, trace);
+    };
+}
+function wrapResponses(originalFn, dataClassification, purpose, reason) {
+    return async function wrappedResponses(...args) {
+        const kwargs = args[0] || {};
+        const model = kwargs.model || 'unknown';
+        const input = kwargs.input ?? '';
+        const isStreaming = kwargs.stream === true;
+        const numInputs = Array.isArray(input) ? input.length : 1;
+        const inputPreview = Array.isArray(input)
+            ? input.slice(0, 3).map((item) => formatInputPreview(item))
+            : [formatInputPreview(input)];
+        const requestPayload = Object.keys(kwargs).length > 0 ? kwargs : { args };
+        const { state, trace } = (0, governance_1.preflightLlmCall)({
+            model,
+            requestPayload,
+            dataClassification,
+            purpose,
+            reason,
+            provider: 'openai',
+            spanName: 'llm_call:openai.responses',
+        });
+        const startEvent = (0, context_1.runInContext)(trace.context, () => {
+            const event = state.eventBuilder.build('llm_call', {
+                model,
+                provider: 'openai',
+                api: 'responses',
+                num_inputs: numInputs,
+                input_preview: inputPreview,
+                stream: isStreaming,
+                status: 'started',
+            }, {
+                dataClassification,
+                purpose,
+                reason,
+            });
+            (0, runtime_1.emitEvent)(event);
+            return event;
+        });
+        (0, lineage_1.setCurrentEvent)(startEvent.event_id);
+        try {
+            const response = await originalFn.apply(this, args);
+            if (isStreaming) {
+                return wrapResponsesStream(response, {
+                    model,
+                    parentEventId: startEvent.event_id,
+                    dataClassification,
+                    purpose,
+                    reason,
+                    state,
+                    trace,
+                });
+            }
+            const completionData = {
+                model: response.model || model,
+            };
+            if (response.usage) {
+                completionData.usage = response.usage;
+            }
+            if (typeof response.output_text === 'string') {
+                completionData.output_text = response.output_text.slice(0, 500);
+                completionData.output_length = response.output_text.length;
+            }
+            (0, context_1.runInContext)(trace.context, () => {
+                const completionEvent = state.eventBuilder.build('llm_call', {
+                    ...completionData,
+                    status: 'success',
+                }, {
+                    dataClassification,
+                    purpose,
+                    parentEventId: startEvent.event_id,
+                });
+                (0, runtime_1.emitEvent)(completionEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state,
+                trace,
+                model,
+                response,
+                dataClassification,
+                purpose,
+                reason,
+            });
+            return response;
+        }
+        catch (error) {
+            if (isGovernanceError(error)) {
+                throw error;
+            }
+            (0, context_1.runInContext)(trace.context, () => {
+                const errorEvent = state.eventBuilder.build('llm_call', {
+                    model,
+                    error: error.message || String(error),
+                    error_type: error.constructor?.name || 'Error',
+                    status: 'error',
+                }, {
+                    dataClassification,
+                    purpose,
+                    parentEventId: startEvent.event_id,
+                });
+                (0, runtime_1.emitEvent)(errorEvent);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state,
+                trace,
+                model,
+                response: null,
+                dataClassification,
+                purpose,
+                reason,
+                error: true,
             });
-            (0, runtime_1.emitEvent)(errorEvent);
             throw error;
         }
     };