@mynitorai/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MyNitor AI TypeScript SDK
+ * The "One-Line Magic" for AI Production Safety.
+ */
+export interface MyNitorConfig {
+    apiKey: string;
+    environment?: string;
+    endpoint?: string;
+}
+export declare class MyNitor {
+    private static instance;
+    private config;
+    private isInstrumented;
+    private constructor();
+    static init(config: MyNitorConfig): MyNitor;
+    /**
+     * Automatically detect and wrap AI libraries like OpenAI
+     */
+    instrument(): void;
+    private sendEvent;
+    private wrapOpenAI;
+}
+export declare const init: typeof MyNitor.init;

package/dist/index.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * MyNitor AI TypeScript SDK
+ * The "One-Line Magic" for AI Production Safety.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = exports.MyNitor = void 0;
+class MyNitor {
+    constructor(config) {
+        this.isInstrumented = false;
+        this.config = {
+            environment: 'production',
+            endpoint: 'https://app.mynitor.ai/api/v1/events',
+            ...config
+        };
+    }
+    static init(config) {
+        if (!MyNitor.instance) {
+            MyNitor.instance = new MyNitor(config);
+        }
+        return MyNitor.instance;
+    }
+    /**
+     * Automatically detect and wrap AI libraries like OpenAI
+     */
+    instrument() {
+        if (this.isInstrumented)
+            return;
+        this.wrapOpenAI();
+        this.isInstrumented = true;
+        console.log('🚀 MyNitor: Auto-instrumentation active.');
+    }
+    async sendEvent(payload) {
+        try {
+            // Fire and forget - we don't await this to keep the user's app fast
+            fetch(this.config.endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.config.apiKey}`
+                },
+                body: JSON.stringify({
+                    ...payload,
+                    environment: this.config.environment,
+                    eventVersion: '1.0'
+                })
+            }).catch(() => {
+                /* Silently fail to protect the user's production app */
+            });
+        }
+        catch (e) {
+            /* Silently fail */
+        }
+    }
+    wrapOpenAI() {
+        try {
+            // Detect if OpenAI is installed
+            const OpenAI = require('openai');
+            if (!OpenAI || !OpenAI.OpenAI)
+                return;
+            const self = this;
+            const originalChatCreate = OpenAI.OpenAI.Chat.Completions.prototype.create;
+            OpenAI.OpenAI.Chat.Completions.prototype.create = async function (...args) {
+                const start = Date.now();
+                const body = args[0];
+                try {
+                    const result = await originalChatCreate.apply(this, args);
+                    const end = Date.now();
+                    // Background capture
+                    self.sendEvent({
+                        requestId: result.id || `req_${Date.now()}`,
+                        model: result.model || body.model,
+                        provider: 'openai',
+                        inputTokens: result.usage?.prompt_tokens || 0,
+                        outputTokens: result.usage?.completion_tokens || 0,
+                        latencyMs: end - start,
+                        status: 'success'
+                    });
+                    return result;
+                }
+                catch (error) {
+                    const end = Date.now();
+                    self.sendEvent({
+                        requestId: `err_${Date.now()}`,
+                        model: body?.model || 'unknown',
+                        provider: 'openai',
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        latencyMs: end - start,
+                        status: 'error',
+                        errorType: error?.constructor?.name || 'Error'
+                    });
+                    throw error;
+                }
+            };
+        }
+        catch (e) {
+            // Library not found or version mismatch - skip silently
+        }
+    }
+}
+exports.MyNitor = MyNitor;
+// Global accessor for snippet simplicity
+exports.init = MyNitor.init;

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@mynitorai/sdk",
+    "version": "0.1.0",
+    "description": "Production safety and observability for AI systems.",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "ai",
+        "observability",
+        "monitoring",
+        "openai",
+        "anthropic",
+        "llm",
+        "safety"
+    ],
+    "author": "MyNitor AI",
+    "license": "MIT",
+    "peerDependencies": {
+        "openai": "^4.0.0"
+    },
+    "devDependencies": {
+        "typescript": "^5.0.0",
+        "openai": "^4.0.0",
+        "@types/node": "^20.0.0"
+    }
+}