monora-ai 2.0.0 → 2.1.3

package/dist/integrations/anthropic.js

@@ -22,8 +22,16 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchAnthropic = patchAnthropic;
+exports.wrapMessagesCreate = wrapMessagesCreate;
+exports.wrapMessagesStream = wrapMessagesStream;
+exports.wrapCompletions = wrapCompletions;
 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 Anthropic client to automatically trace all API calls.
  */
@@ -45,57 +53,110 @@ function patchAnthropic(client, options = {}) {
         client.completions.create = wrapCompletions(originalCreate, dataClassification, purpose, reason);
     }
 }
+function isGovernanceError(error) {
+    return (error instanceof data_handling_1.DataHandlingViolation ||
+        error instanceof policy_1.PolicyViolation ||
+        error instanceof quotas_1.QuotaExceededError);
+}
 function wrapMessagesCreate(originalFn, dataClassification, purpose, reason) {
     return async function wrappedMessagesCreate(...args) {
         const kwargs = args[0] || {};
         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: 'anthropic',
-            api: 'messages',
-            num_messages: messages.length,
-            messages: messages.slice(0, 10),
-            stream: isStreaming,
-            max_tokens: kwargs.max_tokens,
-            temperature: kwargs.temperature,
-            top_p: kwargs.top_p,
-            system: kwargs.system?.slice?.(0, 500) || null,
-        }, {
+            requestPayload,
             dataClassification,
             purpose,
             reason,
+            provider: 'anthropic',
+            spanName: 'llm_call:anthropic.messages',
+        });
+        const startEvent = (0, context_1.runInContext)(trace.context, () => {
+            const event = state.eventBuilder.build('llm_call', {
+                model,
+                provider: 'anthropic',
+                api: 'messages',
+                num_messages: messages.length,
+                messages: messages.slice(0, 10),
+                stream: isStreaming,
+                max_tokens: kwargs.max_tokens,
+                temperature: kwargs.temperature,
+                top_p: kwargs.top_p,
+                system: kwargs.system?.slice?.(0, 500) || null,
+                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 = extractMessageResponse(response, model);
-            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;
         }
     };
@@ -105,30 +166,43 @@ function wrapMessagesStream(originalFn, dataClassification, purpose, reason) {
         const kwargs = args[0] || {};
         const model = kwargs.model || 'unknown';
         const messages = kwargs.messages || [];
-        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: 'anthropic',
-            api: 'messages.stream',
-            num_messages: messages.length,
-            messages: messages.slice(0, 10),
-            stream: true,
-            max_tokens: kwargs.max_tokens,
-            temperature: kwargs.temperature,
-        }, {
+            requestPayload,
             dataClassification,
             purpose,
             reason,
+            provider: 'anthropic',
+            spanName: 'llm_call:anthropic.messages.stream',
+        });
+        const startEvent = (0, context_1.runInContext)(trace.context, () => {
+            const event = state.eventBuilder.build('llm_call', {
+                model,
+                provider: 'anthropic',
+                api: 'messages.stream',
+                num_messages: messages.length,
+                messages: messages.slice(0, 10),
+                stream: true,
+                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);
-        const streamManager = originalFn(...args);
+        const streamManager = originalFn.apply(this, args);
         // Return wrapped stream manager
-        return new StreamManagerWrapper(streamManager, model, startEvent.event_id, dataClassification, purpose, state);
+        return new StreamManagerWrapper(streamManager, model, startEvent.event_id, dataClassification, purpose, reason, state, trace);
     };
 }
 class StreamManagerWrapper {
-    constructor(streamManager, model, parentEventId, dataClassification, purpose, state) {
+    constructor(streamManager, model, parentEventId, dataClassification, purpose, reason, state, trace) {
         this.accumulatedText = '';
         this.usage = {};
         this.streamManager = streamManager;
@@ -136,17 +210,24 @@ class StreamManagerWrapper {
         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 event of this.streamManager) {
                 this.processEvent(event);
                 yield event;
             }
         }
+        catch (err) {
+            error = err;
+            throw err;
+        }
         finally {
-            this.emitCompletion();
+            await this.emitCompletion(error);
         }
     }
     processEvent(event) {
@@ -163,32 +244,74 @@ class StreamManagerWrapper {
             }
         }
     }
-    emitCompletion() {
-        const completionEvent = this.state.eventBuilder.build('llm_call', {
+    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,
+                content: this.accumulatedText.slice(0, 500) || null,
+                content_length: this.accumulatedText.length,
+                usage: this.usage,
+                stream_complete: true,
+                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,
-            content: this.accumulatedText.slice(0, 500) || null,
-            content_length: this.accumulatedText.length,
-            usage: this.usage,
-            stream_complete: true,
-        }, {
+            response: this.usage ? { usage: this.usage } : null,
             dataClassification: this.dataClassification,
             purpose: this.purpose,
-            parentEventId: this.parentEventId,
+            reason: this.reason,
         });
-        (0, runtime_1.emitEvent)(completionEvent);
     }
     // Delegate other methods to underlying stream manager
     on(event, callback) {
         this.streamManager.on?.(event, callback);
         return this;
     }
+    get controller() {
+        return this.streamManager?.controller;
+    }
     async finalMessage() {
         return this.streamManager.finalMessage?.();
     }
 }
-async function* wrapStreamingResponse(stream, model, parentEventId, dataClassification, purpose, state) {
+async function* wrapStreamingResponse(stream, options) {
     let accumulatedText = '';
     let usage = {};
+    let error = null;
     try {
         for await (const event of stream) {
             // Track content from streaming events
@@ -207,20 +330,62 @@ async function* wrapStreamingResponse(stream, model, parentEventId, dataClassifi
             yield event;
         }
     }
+    catch (err) {
+        error = err;
+        throw err;
+    }
     finally {
+        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,
+            });
+            return;
+        }
         // Emit completion event when stream ends
-        const completionEvent = state.eventBuilder.build('llm_call', {
-            model,
-            content: accumulatedText.slice(0, 500) || null,
-            content_length: accumulatedText.length,
-            usage,
-            stream_complete: true,
-        }, {
-            dataClassification,
-            purpose,
-            parentEventId,
+        (0, context_1.runInContext)(options.trace.context, () => {
+            const completionEvent = options.state.eventBuilder.build('llm_call', {
+                model: options.model,
+                content: accumulatedText.slice(0, 500) || null,
+                content_length: accumulatedText.length,
+                usage,
+                stream_complete: true,
+                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: usage ? { usage } : null,
+            dataClassification: options.dataClassification,
+            purpose: options.purpose,
+            reason: options.reason,
         });
-        (0, runtime_1.emitEvent)(completionEvent);
     }
 }
 function extractMessageResponse(response, model) {
@@ -255,23 +420,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: 'anthropic',
-            api: 'completions',
-            prompt: String(prompt).slice(0, 1000),
-            max_tokens_to_sample: kwargs.max_tokens_to_sample,
-            temperature: kwargs.temperature,
-        }, {
+            requestPayload,
             dataClassification,
             purpose,
             reason,
+            provider: 'anthropic',
+            spanName: 'llm_call:anthropic.completions',
+        });
+        const startEvent = (0, context_1.runInContext)(trace.context, () => {
+            const event = state.eventBuilder.build('llm_call', {
+                model,
+                provider: 'anthropic',
+                api: 'completions',
+                prompt: String(prompt).slice(0, 1000),
+                max_tokens_to_sample: kwargs.max_tokens_to_sample,
+                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,
             };
@@ -281,25 +459,52 @@ function wrapCompletions(originalFn, dataClassification, purpose, reason) {
             if (response.stop_reason) {
                 completionData.stop_reason = response.stop_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;
         }
     };

package/dist/integrations/governance.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared governance helpers for SDK integrations.
+ */
+import { ensureState } from '../runtime';
+import type { Span, TraceContext } from '../context';
+export interface LlmTrace {
+    span: Span;
+    context: TraceContext;
+    isRoot: boolean;
+}
+export declare function preflightLlmCall(options: {
+    model?: string;
+    requestPayload: any;
+    dataClassification: string;
+    purpose: string;
+    reason?: string;
+    provider?: string;
+    spanName: string;
+}): {
+    state: ReturnType<typeof ensureState>;
+    trace: LlmTrace;
+};
+export declare function postflightLlmCall(options: {
+    state: ReturnType<typeof ensureState>;
+    trace: LlmTrace;
+    model?: string;
+    response: any;
+    dataClassification: string;
+    purpose: string;
+    reason?: string;
+    error?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=governance.d.ts.map

package/dist/integrations/governance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governance.d.ts","sourceRoot":"","sources":["../../src/integrations/governance.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAIL,WAAW,EAIZ,MAAM,YAAY,CAAC;AAYpB,OAAO,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAIrD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,OAAO,CAAC;CACjB;AA6DD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,GAAG,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG;IAAE,KAAK,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,CAoH7D;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE;IAC/C,KAAK,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACtC,KAAK,EAAE,QAAQ,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC;IACd,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2ChB"}