@mynitorai/sdk 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -4,6 +4,7 @@
  */
 export interface MyNitorConfig {
     apiKey: string;
+    environment?: string;
     endpoint?: string;
 }
 export declare class MyNitor {
@@ -15,7 +16,7 @@ export declare class MyNitor {
     private setupAutoFlush;
     static init(config: MyNitorConfig): MyNitor;
     /**
-     * Automatically detect and wrap AI libraries like OpenAI
+     * Automatically detect and wrap AI libraries: OpenAI, Anthropic, and Google Gemini
      */
     instrument(): void;
     /**
@@ -27,5 +28,7 @@ export declare class MyNitor {
     private getCallSite;
     private sendEvent;
     private wrapOpenAI;
+    private wrapAnthropic;
+    private wrapGemini;
 }
 export declare const init: typeof MyNitor.init;

package/dist/index.js

@@ -5,11 +5,14 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = exports.MyNitor = void 0;
+// Symbol to prevent double-patching (Idempotency)
+const WRAPPED_MARKER = Symbol('mynitor_wrapped');
 class MyNitor {
     constructor(config) {
         this.isInstrumented = false;
         this.pendingPromises = new Set();
         this.config = {
+            environment: 'production',
             endpoint: 'https://app.mynitor.ai/api/v1/events',
             ...config
         };
@@ -21,7 +24,6 @@ class MyNitor {
             process.env.NETLIFY ||
             process.env.FUNCTIONS_WORKER_RUNTIME);
         if (!isServerless && typeof process !== 'undefined' && typeof process.on === 'function') {
-            // Local script or long-running process
             process.on('beforeExit', async () => {
                 await this.flush();
             });
@@ -37,15 +39,16 @@ class MyNitor {
         return MyNitor.instance;
     }
     /**
-     * Automatically detect and wrap AI libraries like OpenAI
+     * Automatically detect and wrap AI libraries: OpenAI, Anthropic, and Google Gemini
      */
     instrument() {
-        // We do NOT check this.isInstrumented here. 
-        // We must check the actual OpenAI object every time, 
-        // because test runners may have reloaded the module.
+        if (this.isInstrumented)
+            return;
         this.wrapOpenAI();
+        this.wrapAnthropic();
+        this.wrapGemini();
         this.isInstrumented = true;
-        console.log('🚀 MyNitor: Auto-instrumentation active.');
+        console.log('🚀 MyNitor: Universal Auto-instrumentation active.');
     }
     /**
      * Waits for all pending network requests to complete.
@@ -64,12 +67,8 @@ class MyNitor {
         try {
             const err = new Error();
             const stack = err.stack?.split('\n') || [];
-            // Look for the frame that called the LLM method
-            // Stack usually: Error -> getCallSite -> wrapOpenAI wrapper -> USER CODE
-            // We iterate to find the first frame NOT in MyNitor SDK
             for (const line of stack) {
                 if (!line.includes('mynitor') && !line.includes('Error') && line.includes('/')) {
-                    // Typical format: "    at Object.myFunction (/path/to/file.ts:10:5)"
                     const match = line.match(/at\s+(?:(.+?)\s+\()?(.*?):(\d+):(\d+)\)?/);
                     if (match) {
                         const func = match[1] || 'anonymous';
@@ -85,15 +84,11 @@ class MyNitor {
                 }
             }
         }
-        catch (e) {
-            // fail safe
-        }
+        catch (e) { }
         return { file: 'unknown', line: 0, functionName: 'unknown', workflowGuess: 'default-workflow' };
     }
     async sendEvent(payload) {
         try {
-            // Fire and forget
-            // Fire and forget (but track)
             const promise = fetch(this.config.endpoint, {
                 method: 'POST',
                 headers: {
@@ -102,6 +97,7 @@ class MyNitor {
                 },
                 body: JSON.stringify({
                     ...payload,
+                    environment: this.config.environment,
                     event_version: '1.0',
                     timestamp: new Date().toISOString()
                 })
@@ -117,22 +113,22 @@ class MyNitor {
     }
     wrapOpenAI() {
         try {
-            const OpenAI = require('openai');
+            let OpenAI = require('openai');
+            if (OpenAI && OpenAI.default)
+                OpenAI = OpenAI.default;
             if (!OpenAI || !OpenAI.OpenAI)
                 return;
-            // Idempotency: Check if already patched on THIS specific instance of the module
-            // This prevents "zombie singleton" issues in test runners that reload modules
-            if (OpenAI.OpenAI.Chat.Completions.prototype.create._isMynitorWrapped) {
+            const target = OpenAI.OpenAI.Chat.Completions.prototype;
+            if (target[WRAPPED_MARKER])
                 return;
-            }
             const self = this;
-            const originalChatCreate = OpenAI.OpenAI.Chat.Completions.prototype.create;
-            const wrapped = async function (...args) {
+            const originalCreate = target.create;
+            target.create = async function (...args) {
                 const start = Date.now();
                 const body = args[0];
                 const callsite = self.getCallSite();
                 try {
-                    const result = await originalChatCreate.apply(this, args);
+                    const result = await originalCreate.apply(this, args);
                     const end = Date.now();
                     self.sendEvent({
                         request_id: result.id || `req_${Date.now()}`,
@@ -167,9 +163,119 @@ class MyNitor {
                     throw error;
                 }
             };
-            // Mark it so we don't wrap it twice on the same module instance
-            wrapped._isMynitorWrapped = true;
-            OpenAI.OpenAI.Chat.Completions.prototype.create = wrapped;
+            target[WRAPPED_MARKER] = true;
+        }
+        catch (e) { }
+    }
+    wrapAnthropic() {
+        try {
+            let Anthropic = require('@anthropic-ai/sdk');
+            if (Anthropic && Anthropic.default)
+                Anthropic = Anthropic.default;
+            if (!Anthropic || !Anthropic.Messages)
+                return;
+            const target = Anthropic.Messages.prototype;
+            if (target[WRAPPED_MARKER])
+                return;
+            const self = this;
+            const originalCreate = target.create;
+            target.create = async function (...args) {
+                const start = Date.now();
+                const body = args[0];
+                const callsite = self.getCallSite();
+                try {
+                    const result = await originalCreate.apply(this, args);
+                    const end = Date.now();
+                    self.sendEvent({
+                        request_id: result.id || `ant_${Date.now()}`,
+                        model: result.model || body.model,
+                        provider: 'anthropic',
+                        agent: 'default-agent',
+                        workflow: callsite.workflowGuess,
+                        file: callsite.file,
+                        function_name: callsite.functionName,
+                        line_number: callsite.line,
+                        input_tokens: result.usage?.input_tokens || 0,
+                        output_tokens: result.usage?.output_tokens || 0,
+                        latency_ms: end - start,
+                        status: 'success'
+                    });
+                    return result;
+                }
+                catch (error) {
+                    const end = Date.now();
+                    self.sendEvent({
+                        request_id: `err_ant_${Date.now()}`,
+                        model: body?.model || 'unknown',
+                        provider: 'anthropic',
+                        agent: 'default-agent',
+                        workflow: callsite.workflowGuess,
+                        file: callsite.file,
+                        function_name: callsite.functionName,
+                        latency_ms: end - start,
+                        status: 'error',
+                        error_type: error?.constructor?.name || 'Error'
+                    });
+                    throw error;
+                }
+            };
+            target[WRAPPED_MARKER] = true;
+        }
+        catch (e) { }
+    }
+    wrapGemini() {
+        try {
+            let GoogleGenAI = require('@google/generative-ai');
+            if (GoogleGenAI && GoogleGenAI.default)
+                GoogleGenAI = GoogleGenAI.default;
+            if (!GoogleGenAI || !GoogleGenAI.GenerativeModel)
+                return;
+            const target = GoogleGenAI.GenerativeModel.prototype;
+            if (target[WRAPPED_MARKER])
+                return;
+            const self = this;
+            const originalGenerate = target.generateContent;
+            target.generateContent = async function (...args) {
+                const start = Date.now();
+                const callsite = self.getCallSite();
+                try {
+                    const result = await originalGenerate.apply(this, args);
+                    const end = Date.now();
+                    const metadata = result.response?.usageMetadata;
+                    self.sendEvent({
+                        request_id: `gem_${Date.now()}`,
+                        model: this.model || 'gemini',
+                        provider: 'google',
+                        agent: 'default-agent',
+                        workflow: callsite.workflowGuess,
+                        file: callsite.file,
+                        function_name: callsite.functionName,
+                        line_number: callsite.line,
+                        input_tokens: metadata?.promptTokenCount || 0,
+                        output_tokens: metadata?.candidatesTokenCount || 0,
+                        latency_ms: end - start,
+                        status: 'success'
+                    });
+                    return result;
+                }
+                catch (error) {
+                    const end = Date.now();
+                    self.sendEvent({
+                        request_id: `err_gem_${Date.now()}`,
+                        model: this.model || 'gemini',
+                        provider: 'google',
+                        agent: 'default-agent',
+                        workflow: callsite.workflowGuess,
+                        file: callsite.file,
+                        function_name: callsite.functionName,
+                        latency_ms: end - start,
+                        status: 'error',
+                        error_type: error?.constructor?.name || 'Error'
+                    });
+                    throw error;
+                }
+            };
+            target[WRAPPED_MARKER] = true;
         }
         catch (e) { }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mynitorai/sdk",
-    "version": "0.1.7",
+    "version": "0.1.9",
     "description": "Production safety and observability for AI systems.",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -30,4 +30,4 @@
         "openai": "^4.0.0",
         "@types/node": "^20.0.0"
     }
-}
+}