monora-ai 2.0.0 → 2.1.3

package/dist/integrations/langchain.js

@@ -22,7 +22,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MonoraCallbackHandler = void 0;
 const runtime_1 = require("../runtime");
+const context_1 = require("../context");
 const lineage_1 = require("../lineage");
+const governance_1 = require("./governance");
+const ids_1 = require("../ids");
 /**
  * LangChain callback handler that traces operations to Monora.
  *
@@ -32,28 +35,92 @@ class MonoraCallbackHandler {
     constructor(options = {}) {
         this.name = 'MonoraCallbackHandler';
         this.runMap = new Map();
+        this.runContexts = new Map();
+        this.llmRuns = new Map();
         this.dataClassification = options.dataClassification ?? 'internal';
         this.purpose = options.purpose ?? 'general';
         this.capturePrompts = options.capturePrompts ?? true;
         this.captureCompletions = options.captureCompletions ?? true;
     }
+    ensureRunContext(runId, parentRunId, spanName) {
+        const existing = this.runContexts.get(runId);
+        if (existing) {
+            return existing;
+        }
+        let baseContext;
+        if (parentRunId) {
+            const parent = this.runContexts.get(parentRunId);
+            if (parent) {
+                baseContext = parent.context;
+            }
+        }
+        if (!baseContext) {
+            baseContext = (0, context_1.captureContext)();
+        }
+        if (!baseContext) {
+            const startTime = Date.now();
+            const span = {
+                traceId: (0, ids_1.generateUlid)('trc'),
+                spanId: (0, ids_1.generateUlid)('spn'),
+                parentSpanId: null,
+                name: spanName,
+                metadata: {},
+            };
+            const context = {
+                currentSpan: span,
+                spanStack: [span],
+                startTime,
+                stepCounter: 0,
+                eventCounter: 0,
+            };
+            (0, context_1.recordTraceStart)(span.traceId, startTime);
+            const runContext = { context, span, created: true };
+            this.runContexts.set(runId, runContext);
+            return runContext;
+        }
+        const span = (0, context_1.runInContext)(baseContext, () => (0, context_1.startSpan)(spanName));
+        const runContext = { context: baseContext, span, created: false };
+        this.runContexts.set(runId, runContext);
+        return runContext;
+    }
+    async finalizeRunContext(runId) {
+        const runContext = this.runContexts.get(runId);
+        if (!runContext) {
+            return;
+        }
+        this.runContexts.delete(runId);
+        if (runContext.created) {
+            const result = (0, context_1.runInContext)(runContext.context, () => (0, context_1.completeTrace)(runContext.span));
+            if (result && typeof result.then === 'function') {
+                await result;
+            }
+            return;
+        }
+        (0, context_1.runInContext)(runContext.context, () => {
+            (0, context_1.popSpan)();
+        });
+    }
     // Chain callbacks
     async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata) {
         const chainType = chain.name || chain.id?.[chain.id.length - 1] || 'unknown';
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('agent_step', {
-            step_type: 'chain_start',
-            chain_type: chainType,
-            inputs: this.capturePrompts ? inputs : { _truncated: true },
-            run_id: runId,
-            parent_run_id: parentRunId || null,
-            tags: tags || [],
-            metadata: metadata || {},
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
+        const runContext = this.ensureRunContext(runId, parentRunId, 'langchain.chain');
+        const event = (0, context_1.runInContext)(runContext.context, () => {
+            const state = (0, runtime_1.ensureState)();
+            const built = state.eventBuilder.build('agent_step', {
+                step_type: 'chain_start',
+                chain_type: chainType,
+                inputs: this.capturePrompts ? inputs : { _truncated: true },
+                run_id: runId,
+                parent_run_id: parentRunId || null,
+                tags: tags || [],
+                metadata: metadata || {},
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(built);
+            return built;
         });
-        (0, runtime_1.emitEvent)(event);
         this.runMap.set(runId, event.event_id);
         (0, lineage_1.setCurrentEvent)(event.event_id);
     }
@@ -62,35 +129,57 @@ class MonoraCallbackHandler {
         if (parentEventId) {
             (0, lineage_1.addInputEvent)(parentEventId);
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('agent_step', {
-            step_type: 'chain_end',
-            outputs: this.captureCompletions ? outputs : { _truncated: true },
-            run_id: runId,
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
-        });
-        (0, runtime_1.emitEvent)(event);
+        const runContext = this.runContexts.get(runId);
+        const ctx = runContext?.context;
+        const emit = () => {
+            const state = (0, runtime_1.ensureState)();
+            const event = state.eventBuilder.build('agent_step', {
+                step_type: 'chain_end',
+                outputs: this.captureCompletions ? outputs : { _truncated: true },
+                run_id: runId,
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(event);
+        };
+        if (ctx) {
+            (0, context_1.runInContext)(ctx, emit);
+        }
+        else {
+            emit();
+        }
         this.runMap.delete(runId);
+        await this.finalizeRunContext(runId);
     }
     async handleChainError(error, runId, parentRunId) {
         const parentEventId = this.runMap.get(runId);
         if (parentEventId) {
             (0, lineage_1.addInputEvent)(parentEventId);
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('agent_step', {
-            step_type: 'chain_error',
-            error: error.message || String(error),
-            error_type: error.constructor?.name || 'Error',
-            run_id: runId,
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
-        });
-        (0, runtime_1.emitEvent)(event);
+        const runContext = this.runContexts.get(runId);
+        const ctx = runContext?.context;
+        const emit = () => {
+            const state = (0, runtime_1.ensureState)();
+            const event = state.eventBuilder.build('agent_step', {
+                step_type: 'chain_error',
+                error: error.message || String(error),
+                error_type: error.constructor?.name || 'Error',
+                run_id: runId,
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(event);
+        };
+        if (ctx) {
+            (0, context_1.runInContext)(ctx, emit);
+        }
+        else {
+            emit();
+        }
         this.runMap.delete(runId);
+        await this.finalizeRunContext(runId);
     }
     // LLM callbacks
     async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
@@ -104,24 +193,42 @@ class MonoraCallbackHandler {
                 (0, lineage_1.addInputEvent)(parentEventId);
             }
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('llm_call', {
+        const requestPayload = {
+            prompts,
+            metadata,
+            tags,
+            extra: extraParams,
+        };
+        const { state, trace } = (0, governance_1.preflightLlmCall)({
             model,
-            provider: 'langchain',
-            prompts: this.capturePrompts
-                ? prompts
-                : prompts.map((p) => `<${p.length} chars>`),
-            num_prompts: prompts.length,
-            run_id: runId,
-            parent_run_id: parentRunId || null,
-            tags: tags || [],
-            metadata: metadata || {},
-        }, {
+            requestPayload,
             dataClassification: this.dataClassification,
             purpose: this.purpose,
+            provider: 'langchain',
+            spanName: 'llm_call:langchain',
+        });
+        const event = (0, context_1.runInContext)(trace.context, () => {
+            const built = state.eventBuilder.build('llm_call', {
+                model,
+                provider: 'langchain',
+                prompts: this.capturePrompts
+                    ? prompts
+                    : prompts.map((p) => `<${p.length} chars>`),
+                num_prompts: prompts.length,
+                run_id: runId,
+                parent_run_id: parentRunId || null,
+                tags: tags || [],
+                metadata: metadata || {},
+                status: 'started',
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(built);
+            return built;
         });
-        (0, runtime_1.emitEvent)(event);
         this.runMap.set(runId, event.event_id);
+        this.llmRuns.set(runId, { state, trace, model });
         (0, lineage_1.setCurrentEvent)(event.event_id);
     }
     async handleLLMEnd(output, runId, parentRunId) {
@@ -134,7 +241,31 @@ class MonoraCallbackHandler {
         if (output.generations) {
             for (const generationList of output.generations) {
                 for (const gen of generationList) {
-                    const text = gen.text || String(gen);
+                    const text = (() => {
+                        if (typeof gen?.text === 'string') {
+                            return gen.text;
+                        }
+                        if (typeof gen?.message?.content === 'string') {
+                            return gen.message.content;
+                        }
+                        if (typeof gen?.toString === 'function') {
+                            try {
+                                const stringValue = gen.toString();
+                                if (typeof stringValue === 'string' && stringValue !== '[object Object]') {
+                                    return stringValue;
+                                }
+                            }
+                            catch {
+                                // Ignore toString failures and fall through.
+                            }
+                        }
+                        try {
+                            return JSON.stringify(gen);
+                        }
+                        catch {
+                            return String(gen);
+                        }
+                    })();
                     if (this.captureCompletions) {
                         completions.push(text);
                     }
@@ -144,17 +275,45 @@ class MonoraCallbackHandler {
                 }
             }
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('llm_call', {
-            completions,
-            num_completions: completions.length,
-            token_usage: tokenUsage,
-            run_id: runId,
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
-        });
-        (0, runtime_1.emitEvent)(event);
+        const runInfo = this.llmRuns.get(runId);
+        if (runInfo) {
+            (0, context_1.runInContext)(runInfo.trace.context, () => {
+                const event = runInfo.state.eventBuilder.build('llm_call', {
+                    completions,
+                    num_completions: completions.length,
+                    token_usage: tokenUsage,
+                    run_id: runId,
+                    status: 'success',
+                }, {
+                    dataClassification: this.dataClassification,
+                    purpose: this.purpose,
+                });
+                (0, runtime_1.emitEvent)(event);
+            });
+            const responseStub = Object.keys(tokenUsage).length > 0 ? { usage: tokenUsage } : null;
+            await (0, governance_1.postflightLlmCall)({
+                state: runInfo.state,
+                trace: runInfo.trace,
+                model: runInfo.model,
+                response: responseStub,
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            this.llmRuns.delete(runId);
+        }
+        else {
+            const state = (0, runtime_1.ensureState)();
+            const event = state.eventBuilder.build('llm_call', {
+                completions,
+                num_completions: completions.length,
+                token_usage: tokenUsage,
+                run_id: runId,
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(event);
+        }
         this.runMap.delete(runId);
     }
     async handleLLMError(error, runId, parentRunId) {
@@ -162,16 +321,43 @@ class MonoraCallbackHandler {
         if (parentEventId) {
             (0, lineage_1.addInputEvent)(parentEventId);
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('llm_call', {
-            error: error.message || String(error),
-            error_type: error.constructor?.name || 'Error',
-            run_id: runId,
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
-        });
-        (0, runtime_1.emitEvent)(event);
+        const runInfo = this.llmRuns.get(runId);
+        if (runInfo) {
+            (0, context_1.runInContext)(runInfo.trace.context, () => {
+                const event = runInfo.state.eventBuilder.build('llm_call', {
+                    error: error.message || String(error),
+                    error_type: error.constructor?.name || 'Error',
+                    run_id: runId,
+                    status: 'error',
+                }, {
+                    dataClassification: this.dataClassification,
+                    purpose: this.purpose,
+                });
+                (0, runtime_1.emitEvent)(event);
+            });
+            await (0, governance_1.postflightLlmCall)({
+                state: runInfo.state,
+                trace: runInfo.trace,
+                model: runInfo.model,
+                response: null,
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+                error: true,
+            });
+            this.llmRuns.delete(runId);
+        }
+        else {
+            const state = (0, runtime_1.ensureState)();
+            const event = state.eventBuilder.build('llm_call', {
+                error: error.message || String(error),
+                error_type: error.constructor?.name || 'Error',
+                run_id: runId,
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(event);
+        }
         this.runMap.delete(runId);
     }
     // Tool callbacks
@@ -183,19 +369,23 @@ class MonoraCallbackHandler {
                 (0, lineage_1.addInputEvent)(parentEventId);
             }
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('tool_call', {
-            tool_name: toolName,
-            input: this.capturePrompts ? input : `<${input.length} chars>`,
-            run_id: runId,
-            parent_run_id: parentRunId || null,
-            tags: tags || [],
-            metadata: metadata || {},
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
+        const runContext = this.ensureRunContext(runId, parentRunId, 'langchain.tool');
+        const event = (0, context_1.runInContext)(runContext.context, () => {
+            const state = (0, runtime_1.ensureState)();
+            const built = state.eventBuilder.build('tool_call', {
+                tool_name: toolName,
+                input: this.capturePrompts ? input : `<${input.length} chars>`,
+                run_id: runId,
+                parent_run_id: parentRunId || null,
+                tags: tags || [],
+                metadata: metadata || {},
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(built);
+            return built;
         });
-        (0, runtime_1.emitEvent)(event);
         this.runMap.set(runId, event.event_id);
         (0, lineage_1.setCurrentEvent)(event.event_id);
     }
@@ -204,33 +394,55 @@ class MonoraCallbackHandler {
         if (parentEventId) {
             (0, lineage_1.addInputEvent)(parentEventId);
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('tool_call', {
-            output: this.captureCompletions ? output : `<${output.length} chars>`,
-            run_id: runId,
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
-        });
-        (0, runtime_1.emitEvent)(event);
+        const runContext = this.runContexts.get(runId);
+        const ctx = runContext?.context;
+        const emit = () => {
+            const state = (0, runtime_1.ensureState)();
+            const event = state.eventBuilder.build('tool_call', {
+                output: this.captureCompletions ? output : `<${output.length} chars>`,
+                run_id: runId,
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(event);
+        };
+        if (ctx) {
+            (0, context_1.runInContext)(ctx, emit);
+        }
+        else {
+            emit();
+        }
         this.runMap.delete(runId);
+        await this.finalizeRunContext(runId);
     }
     async handleToolError(error, runId, parentRunId) {
         const parentEventId = this.runMap.get(runId);
         if (parentEventId) {
             (0, lineage_1.addInputEvent)(parentEventId);
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('tool_call', {
-            error: error.message || String(error),
-            error_type: error.constructor?.name || 'Error',
-            run_id: runId,
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
-        });
-        (0, runtime_1.emitEvent)(event);
+        const runContext = this.runContexts.get(runId);
+        const ctx = runContext?.context;
+        const emit = () => {
+            const state = (0, runtime_1.ensureState)();
+            const event = state.eventBuilder.build('tool_call', {
+                error: error.message || String(error),
+                error_type: error.constructor?.name || 'Error',
+                run_id: runId,
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(event);
+        };
+        if (ctx) {
+            (0, context_1.runInContext)(ctx, emit);
+        }
+        else {
+            emit();
+        }
         this.runMap.delete(runId);
+        await this.finalizeRunContext(runId);
     }
     // Retriever callbacks
     async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata) {
@@ -240,19 +452,23 @@ class MonoraCallbackHandler {
                 (0, lineage_1.addInputEvent)(parentEventId);
             }
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('custom', {
-            custom_type: 'retriever_query',
-            query: this.capturePrompts ? query : `<${query.length} chars>`,
-            run_id: runId,
-            parent_run_id: parentRunId || null,
-            tags: tags || [],
-            metadata: metadata || {},
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
+        const runContext = this.ensureRunContext(runId, parentRunId, 'langchain.retriever');
+        const event = (0, context_1.runInContext)(runContext.context, () => {
+            const state = (0, runtime_1.ensureState)();
+            const built = state.eventBuilder.build('custom', {
+                custom_type: 'retriever_query',
+                query: this.capturePrompts ? query : `<${query.length} chars>`,
+                run_id: runId,
+                parent_run_id: parentRunId || null,
+                tags: tags || [],
+                metadata: metadata || {},
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(built);
+            return built;
         });
-        (0, runtime_1.emitEvent)(event);
         this.runMap.set(runId, event.event_id);
         (0, lineage_1.setCurrentEvent)(event.event_id);
     }
@@ -261,46 +477,74 @@ class MonoraCallbackHandler {
         if (parentEventId) {
             (0, lineage_1.addInputEvent)(parentEventId);
         }
-        const docSummaries = documents.slice(0, 10).map((doc) => {
-            const summary = {
-                page_content_length: doc.pageContent?.length || 0,
-                metadata: doc.metadata || {},
-            };
-            if (this.captureCompletions && doc.pageContent) {
-                summary.page_content = doc.pageContent.slice(0, 500);
+        const runContext = this.runContexts.get(runId);
+        const ctx = runContext?.context;
+        const emit = () => {
+            for (const doc of documents) {
+                const source = doc.metadata?.source;
+                if (typeof source === 'string' && source.trim()) {
+                    (0, lineage_1.addDataSource)(source);
+                }
             }
-            return summary;
-        });
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('custom', {
-            custom_type: 'retriever_result',
-            num_documents: documents.length,
-            documents: docSummaries,
-            run_id: runId,
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
-        });
-        (0, runtime_1.emitEvent)(event);
+            const docSummaries = documents.slice(0, 10).map((doc) => {
+                const summary = {
+                    page_content_length: doc.pageContent?.length || 0,
+                    metadata: doc.metadata || {},
+                };
+                if (this.captureCompletions && doc.pageContent) {
+                    summary.page_content = doc.pageContent.slice(0, 500);
+                }
+                return summary;
+            });
+            const state = (0, runtime_1.ensureState)();
+            const event = state.eventBuilder.build('custom', {
+                custom_type: 'retriever_result',
+                num_documents: documents.length,
+                documents: docSummaries,
+                run_id: runId,
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(event);
+        };
+        if (ctx) {
+            (0, context_1.runInContext)(ctx, emit);
+        }
+        else {
+            emit();
+        }
         this.runMap.delete(runId);
+        await this.finalizeRunContext(runId);
     }
     async handleRetrieverError(error, runId, parentRunId) {
         const parentEventId = this.runMap.get(runId);
         if (parentEventId) {
             (0, lineage_1.addInputEvent)(parentEventId);
         }
-        const state = (0, runtime_1.ensureState)();
-        const event = state.eventBuilder.build('custom', {
-            custom_type: 'retriever_error',
-            error: error.message || String(error),
-            error_type: error.constructor?.name || 'Error',
-            run_id: runId,
-        }, {
-            dataClassification: this.dataClassification,
-            purpose: this.purpose,
-        });
-        (0, runtime_1.emitEvent)(event);
+        const runContext = this.runContexts.get(runId);
+        const ctx = runContext?.context;
+        const emit = () => {
+            const state = (0, runtime_1.ensureState)();
+            const event = state.eventBuilder.build('custom', {
+                custom_type: 'retriever_error',
+                error: error.message || String(error),
+                error_type: error.constructor?.name || 'Error',
+                run_id: runId,
+            }, {
+                dataClassification: this.dataClassification,
+                purpose: this.purpose,
+            });
+            (0, runtime_1.emitEvent)(event);
+        };
+        if (ctx) {
+            (0, context_1.runInContext)(ctx, emit);
+        }
+        else {
+            emit();
+        }
         this.runMap.delete(runId);
+        await this.finalizeRunContext(runId);
     }
 }
 exports.MonoraCallbackHandler = MonoraCallbackHandler;

package/dist/integrations/openai.d.ts

@@ -35,10 +35,19 @@ interface OpenAIClient {
     embeddings?: {
         create: (...args: any[]) => any;
     };
+    responses?: {
+        create: (...args: any[]) => any;
+        stream?: (...args: any[]) => any;
+    };
 }
 /**
  * Patch an OpenAI client to automatically trace all API calls.
  */
 export declare function patchOpenAI(client: OpenAIClient, options?: PatchOpenAIOptions): void;
+export declare function wrapChatCompletions(originalFn: (...args: any[]) => any, dataClassification: string, purpose: string, reason?: string): (...args: any[]) => any;
+export declare function wrapCompletions(originalFn: (...args: any[]) => any, dataClassification: string, purpose: string, reason?: string): (...args: any[]) => any;
+export declare function wrapEmbeddings(originalFn: (...args: any[]) => any, dataClassification: string, purpose: string, reason?: string): (...args: any[]) => any;
+export declare function wrapResponsesStreamMethod(originalFn: (...args: any[]) => any, dataClassification: string, purpose: string, reason?: string): (...args: any[]) => any;
+export declare function wrapResponses(originalFn: (...args: any[]) => any, dataClassification: string, purpose: string, reason?: string): (...args: any[]) => any;
 export {};
 //# sourceMappingURL=openai.d.ts.map