monora-ai 2.0.0 → 2.1.3

package/dist/instrumentation.js

@@ -10,7 +10,6 @@ exports.InstrumentationError = void 0;
 exports.autoInstrument = autoInstrument;
 exports.uninstrument = uninstrument;
 const logger_1 = require("./logger");
-const runtime_1 = require("./runtime");
 class InstrumentationError extends Error {
     constructor(message) {
         super(message);
@@ -18,6 +17,18 @@ class InstrumentationError extends Error {
     }
 }
 exports.InstrumentationError = InstrumentationError;
+const patchRegistry = new WeakMap();
+function registerPatch(target, methodName, original) {
+    let targetPatches = patchRegistry.get(target);
+    if (!targetPatches) {
+        targetPatches = new Map();
+        patchRegistry.set(target, targetPatches);
+    }
+    if (targetPatches.has(methodName)) {
+        return;
+    }
+    targetPatches.set(methodName, original);
+}
 /**
  * Apply optional auto-instrumentation for supported SDKs.
  */
@@ -28,8 +39,8 @@ function autoInstrument(config, options) {
     }
     const targets = settings.targets || ['openai', 'anthropic'];
     const purpose = settings.default_purpose || config.defaults?.purpose || 'general';
-    const dataClassification = settings.data_classification;
-    const reason = settings.reason;
+    const dataClassification = settings.data_classification ?? undefined;
+    const reason = settings.reason ?? undefined;
     const effectiveFailFast = options?.failFast ?? settings.fail_fast ?? false;
     const report = {
         enabled: true,
@@ -45,6 +56,12 @@ function autoInstrument(config, options) {
         else if (target === 'anthropic') {
             [patched, errors] = instrumentAnthropic({ purpose, reason, dataClassification });
         }
+        else if (target === 'langchain') {
+            const langchainConfig = settings && typeof settings.langchain === 'object'
+                ? settings.langchain
+                : {};
+            [patched, errors] = instrumentLangChain({ purpose, reason, dataClassification }, langchainConfig);
+        }
         else {
             patched = [];
             errors = [`Unknown instrumentation target '${target}'`];
@@ -84,6 +101,8 @@ function instrumentOpenAI(opts) {
             { path: 'chat.completions', method: 'create' },
             { path: 'completions', method: 'create' },
             { path: 'responses', method: 'create' },
+            { path: 'responses', method: 'stream' },
+            { path: 'embeddings', method: 'create' },
         ];
         for (const target of patchTargets) {
             try {
@@ -121,13 +140,28 @@ function patchOpenAIMethod(OpenAI, resourcePath, methodName, opts) {
     // Try to find the resource class
     // OpenAI v4 structure: OpenAI instance has _client with resource namespaces
     try {
-        // Create a temporary instance to inspect structure (without making API calls)
-        const instance = new OpenAI({ apiKey: 'sk-test', dangerouslyAllowBrowser: true });
+        let current;
+        let inspectionSource = 'instance';
+        try {
+            // Create a temporary instance to inspect structure (without making API calls)
+            const instance = new OpenAI({ apiKey: 'sk-test', dangerouslyAllowBrowser: true });
+            current = instance;
+        }
+        catch (err) {
+            logger_1.logger.warning('OpenAI inspection instance failed; falling back to prototype: %s', err);
+            current = OpenAI?.prototype;
+            inspectionSource = 'prototype';
+        }
+        if (!current) {
+            return { success: false, error: 'OpenAI inspection failed: no instance or prototype available' };
+        }
         // Navigate to the resource
-        let current = instance;
         for (const part of pathParts) {
             if (!current[part]) {
-                return { success: false, error: `Resource ${resourcePath} not found on OpenAI instance` };
+                return {
+                    success: false,
+                    error: `Resource ${resourcePath} not found on OpenAI ${inspectionSource}`,
+                };
             }
             current = current[part];
         }
@@ -140,17 +174,19 @@ function patchOpenAIMethod(OpenAI, resourcePath, methodName, opts) {
         if (resourceClass[methodName].__monora_wrapped__) {
             return { success: true };
         }
+        const wrapperFactory = getOpenAIWrapperFactory(resourcePath, methodName, opts);
+        if (!wrapperFactory) {
+            return { success: false, error: `No wrapper available for ${resourcePath}.${methodName}` };
+        }
         // Store original method
         const originalMethod = resourceClass[methodName];
-        // Create wrapped method
+        registerPatch(resourceClass, methodName, originalMethod);
+        // Create wrapped method once at patch time
+        const wrappedFn = wrapperFactory(function (...args) {
+            return originalMethod.apply(this, args);
+        });
         resourceClass[methodName] = function (...args) {
-            // Use the llmCall decorator pattern
-            const wrappedFn = (0, runtime_1.llmCall)({
-                purpose: opts.purpose,
-                reason: opts.reason,
-                dataClassification: opts.dataClassification,
-            })(originalMethod.bind(this));
-            return wrappedFn(...args);
+            return wrappedFn.apply(this, args);
         };
         // Mark as wrapped
         resourceClass[methodName].__monora_wrapped__ = true;
@@ -160,6 +196,38 @@ function patchOpenAIMethod(OpenAI, resourcePath, methodName, opts) {
         return { success: false, error: `Patch error for ${resourcePath}.${methodName}: ${err}` };
     }
 }
+function getOpenAIWrapperFactory(resourcePath, methodName, opts) {
+    let wrappers;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        wrappers = require('./integrations/openai');
+    }
+    catch {
+        return null;
+    }
+    const buildFactory = (wrapper) => {
+        if (typeof wrapper !== 'function') {
+            return null;
+        }
+        return (originalFn) => wrapper(originalFn, opts.dataClassification || 'internal', opts.purpose, opts.reason);
+    };
+    if (resourcePath === 'chat.completions' && methodName === 'create') {
+        return buildFactory(wrappers.wrapChatCompletions);
+    }
+    if (resourcePath === 'completions' && methodName === 'create') {
+        return buildFactory(wrappers.wrapCompletions);
+    }
+    if (resourcePath === 'embeddings' && methodName === 'create') {
+        return buildFactory(wrappers.wrapEmbeddings);
+    }
+    if (resourcePath === 'responses' && methodName === 'create') {
+        return buildFactory(wrappers.wrapResponses);
+    }
+    if (resourcePath === 'responses' && methodName === 'stream') {
+        return buildFactory(wrappers.wrapResponsesStreamMethod);
+    }
+    return null;
+}
 /**
  * Instrument Anthropic SDK methods.
  */
@@ -186,6 +254,7 @@ function instrumentAnthropic(opts) {
         const Anthropic = anthropicModule.default || anthropicModule.Anthropic || anthropicModule;
         const patchTargets = [
             { path: 'messages', method: 'create' },
+            { path: 'messages', method: 'stream' },
             { path: 'completions', method: 'create' },
         ];
         for (const target of patchTargets) {
@@ -208,6 +277,112 @@ function instrumentAnthropic(opts) {
     }
     return [patched, errors];
 }
+/**
+ * Instrument LangChain callback manager to attach Monora handler.
+ */
+function instrumentLangChain(opts, langchainConfig) {
+    if (!moduleAvailable('langchain')) {
+        return [[], ['LangChain SDK not installed; skipping auto-instrumentation']];
+    }
+    const patched = [];
+    const errors = [];
+    let managerModule;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        managerModule = require('langchain/callbacks/manager');
+    }
+    catch (err) {
+        errors.push(`Failed to load LangChain callback manager: ${err}`);
+        return [patched, errors];
+    }
+    let MonoraCallbackHandler;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        ({ MonoraCallbackHandler } = require('./integrations/langchain'));
+    }
+    catch (err) {
+        errors.push(`Failed to load Monora LangChain handler: ${err}`);
+        return [patched, errors];
+    }
+    const capturePrompts = langchainConfig.capture_prompts ??
+        langchainConfig.capturePrompts ??
+        true;
+    const captureCompletions = langchainConfig.capture_completions ??
+        langchainConfig.captureCompletions ??
+        true;
+    const handler = new MonoraCallbackHandler({
+        dataClassification: opts.dataClassification,
+        purpose: opts.purpose,
+        capturePrompts,
+        captureCompletions,
+    });
+    const CallbackManager = managerModule.CallbackManager ||
+        managerModule.default?.CallbackManager ||
+        managerModule.default;
+    if (!CallbackManager) {
+        errors.push('LangChain CallbackManager not found');
+        return [patched, errors];
+    }
+    const factoryNames = ['configure', 'fromHandlers', 'fromMethods', 'fromCallbacks'];
+    for (const factoryName of factoryNames) {
+        const factory = CallbackManager[factoryName];
+        if (typeof factory !== 'function') {
+            continue;
+        }
+        if (factory.__monora_wrapped__) {
+            continue;
+        }
+        registerPatch(CallbackManager, factoryName, factory);
+        const wrapped = function (...args) {
+            const manager = factory.apply(this, args);
+            attachLangChainHandler(manager, handler);
+            return manager;
+        };
+        wrapped.__monora_wrapped__ = true;
+        CallbackManager[factoryName] = wrapped;
+        patched.push(`langchain.callbacks.manager.CallbackManager.${factoryName}`);
+    }
+    if (patched.length === 0) {
+        errors.push('LangChain CallbackManager factories not found or already instrumented');
+    }
+    return [patched, errors];
+}
+function attachLangChainHandler(manager, handler) {
+    if (!manager || hasLangChainHandler(manager)) {
+        return;
+    }
+    if (typeof manager.addHandler === 'function') {
+        try {
+            manager.addHandler(handler);
+            return;
+        }
+        catch {
+            // fall through to array-based attach
+        }
+    }
+    if (Array.isArray(manager.handlers)) {
+        manager.handlers.push(handler);
+    }
+    if (Array.isArray(manager.inheritableHandlers)) {
+        manager.inheritableHandlers.push(handler);
+    }
+}
+function hasLangChainHandler(manager) {
+    const candidates = [];
+    if (Array.isArray(manager?.handlers)) {
+        candidates.push(...manager.handlers);
+    }
+    if (Array.isArray(manager?.inheritableHandlers)) {
+        candidates.push(...manager.inheritableHandlers);
+    }
+    return candidates.some((candidate) => {
+        if (!candidate) {
+            return false;
+        }
+        const name = candidate.name || candidate.constructor?.name;
+        return name === 'MonoraCallbackHandler';
+    });
+}
 /**
  * Patch a specific Anthropic method.
  */
@@ -233,16 +408,19 @@ function patchAnthropicMethod(Anthropic, resourcePath, methodName, opts) {
         if (resourceClass[methodName].__monora_wrapped__) {
             return { success: true };
         }
+        const wrapperFactory = getAnthropicWrapperFactory(resourcePath, methodName, opts);
+        if (!wrapperFactory) {
+            return { success: false, error: `No wrapper available for ${resourcePath}.${methodName}` };
+        }
         // Store original method
         const originalMethod = resourceClass[methodName];
-        // Create wrapped method
+        registerPatch(resourceClass, methodName, originalMethod);
+        // Create wrapped method once at patch time
+        const wrappedFn = wrapperFactory(function (...args) {
+            return originalMethod.apply(this, args);
+        });
         resourceClass[methodName] = function (...args) {
-            const wrappedFn = (0, runtime_1.llmCall)({
-                purpose: opts.purpose,
-                reason: opts.reason,
-                dataClassification: opts.dataClassification,
-            })(originalMethod.bind(this));
-            return wrappedFn(...args);
+            return wrappedFn.apply(this, args);
         };
         // Mark as wrapped
         resourceClass[methodName].__monora_wrapped__ = true;
@@ -252,6 +430,32 @@ function patchAnthropicMethod(Anthropic, resourcePath, methodName, opts) {
         return { success: false, error: `Patch error for ${resourcePath}.${methodName}: ${err}` };
     }
 }
+function getAnthropicWrapperFactory(resourcePath, methodName, opts) {
+    let wrappers;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        wrappers = require('./integrations/anthropic');
+    }
+    catch {
+        return null;
+    }
+    const buildFactory = (wrapper) => {
+        if (typeof wrapper !== 'function') {
+            return null;
+        }
+        return (originalFn) => wrapper(originalFn, opts.dataClassification || 'internal', opts.purpose, opts.reason);
+    };
+    if (resourcePath === 'messages' && methodName === 'create') {
+        return buildFactory(wrappers.wrapMessagesCreate);
+    }
+    if (resourcePath === 'messages' && methodName === 'stream') {
+        return buildFactory(wrappers.wrapMessagesStream);
+    }
+    if (resourcePath === 'completions' && methodName === 'create') {
+        return buildFactory(wrappers.wrapCompletions);
+    }
+    return null;
+}
 /**
  * Check if a module is available.
  */
@@ -267,9 +471,21 @@ function moduleAvailable(name) {
 /**
  * Uninstrument all patched methods (useful for testing).
  */
-function uninstrument() {
-    // This would need to store references to original methods
-    // For now, this is a placeholder - full implementation would track
-    // all patched methods and restore them
-    logger_1.logger.warning('uninstrument() not fully implemented');
+function uninstrument(target) {
+    if (!target) {
+        return;
+    }
+    const targetPatches = patchRegistry.get(target);
+    if (!targetPatches) {
+        return;
+    }
+    for (const [methodName, original] of targetPatches.entries()) {
+        try {
+            target[methodName] = original;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to restore %s: %s', methodName, error);
+        }
+    }
+    patchRegistry.delete(target);
 }

package/dist/integrations/anthropic.d.ts

@@ -37,5 +37,8 @@ interface AnthropicClient {
  * Patch an Anthropic client to automatically trace all API calls.
  */
 export declare function patchAnthropic(client: AnthropicClient, options?: PatchAnthropicOptions): void;
+export declare function wrapMessagesCreate(originalFn: (...args: any[]) => any, dataClassification: string, purpose: string, reason?: string): (...args: any[]) => any;
+export declare function wrapMessagesStream(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 {};
 //# sourceMappingURL=anthropic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../src/integrations/anthropic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAKH,MAAM,WAAW,qBAAqB;IACpC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,eAAe;IACvB,QAAQ,CAAC,EAAE;QACT,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;QAChC,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;KAClC,CAAC;IACF,WAAW,CAAC,EAAE;QACZ,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;KACjC,CAAC;CACH;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,eAAe,EACvB,OAAO,GAAE,qBAA0B,GAClC,IAAI,CAuCN"}
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../src/integrations/anthropic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAUH,MAAM,WAAW,qBAAqB;IACpC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,eAAe;IACvB,QAAQ,CAAC,EAAE;QACT,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;QAChC,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;KAClC,CAAC;IACF,WAAW,CAAC,EAAE;QACZ,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;KACjC,CAAC;CACH;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,eAAe,EACvB,OAAO,GAAE,qBAA0B,GAClC,IAAI,CAuCN;AAUD,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACnC,kBAAkB,EAAE,MAAM,EAC1B,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CA0HzB;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACnC,kBAAkB,EAAE,MAAM,EAC1B,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAuDzB;AA+QD,wBAAgB,eAAe,CAC7B,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACnC,kBAAkB,EAAE,MAAM,EAC1B,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAgHzB"}