@dropout-ai/runtime 0.5.1 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dropout-ai/runtime",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Invisible Node.js runtime for understanding behavioral impact of AI interactions.",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/index.js

@@ -1,11 +1,10 @@
 /**
  * @dropout-ai/runtime
  * Universal AI Interaction Capture for Node.js
- * Stability: Production (Async-Safe, Zero Config)
+ * Stability: High (Browser-Safe, Next.js Safe)
  */
 
 let https, http, crypto;
-const { AsyncLocalStorage } = require('async_hooks');
 
 // --- DEFAULT CONFIGURATION ---
 const SUPABASE_FUNCTION_URL =
@@ -13,43 +12,43 @@ const SUPABASE_FUNCTION_URL =
 
 // Known AI Domains
 const KNOWN_AI_DOMAINS = [
-  'api.openai.com',
-  'api.anthropic.com',
-  'generativelanguage.googleapis.com',
-  'aiplatform.googleapis.com',
-  'api.groq.com',
-  'api.mistral.ai',
-  'api.cohere.ai'
+  "api.openai.com",
+  "api.anthropic.com",
+  "generativelanguage.googleapis.com",
+  "aiplatform.googleapis.com",
+  "api.groq.com",
+  "api.mistral.ai",
+  "api.cohere.ai",
 ];
 
 class Dropout {
   static instance = null;
 
   static init(config) {
-    if (!Dropout.instance) {
-      new Dropout(config);
-    }
+    if (!Dropout.instance) new Dropout(config);
     return Dropout.instance;
   }
 
   constructor(config = {}) {
     if (Dropout.instance) return Dropout.instance;
 
-    // 🛡️ Browser Guard
-    if (typeof window !== 'undefined') return;
+    // 🛡️ Browser Guard (prevents client execution)
+    if (typeof window !== "undefined" && typeof window.document !== "undefined") {
+      return;
+    }
 
-    // 🛡️ Credentials Guard
+    // 🛡️ Credential Guard
     if (!config.apiKey || !config.projectId) {
       if (config.debug) {
-        console.warn("[Dropout] 🔴 Missing API Key or Project ID.");
+        console.warn("[Dropout] Missing API Key or Project ID");
       }
       return;
     }
 
     try {
-      https = require('https');
-      http = require('http');
-      crypto = require('crypto');
+      https = require("https");
+      http = require("http");
+      crypto = require("crypto");
     } catch {
       return;
     }
@@ -57,89 +56,100 @@ class Dropout {
     this.projectId = config.projectId;
     this.apiKey = config.apiKey;
     this.debug = config.debug || false;
-    this.privacy = config.privacy || 'full';
+    this.privacy = config.privacy || "full";
     this.captureEndpoint = config.captureEndpoint || SUPABASE_FUNCTION_URL;
     this.maxOutputBytes = 32768;
 
-    // ✅ ASYNC CONTEXT STORE (THE FIX)
-    this.ctx = new AsyncLocalStorage();
+    // --------------------------------------------------
+    // ✅ ASYNC CONTEXT (LAZY, NODE-ONLY)
+    // --------------------------------------------------
+    this.storage = null;
+
+    try {
+      const asyncHooks = require("async_hooks");
+      this.storage = new asyncHooks.AsyncLocalStorage();
+    } catch {
+      // Edge / Browser / Unsupported — safely disabled
+      this.storage = null;
+    }
 
+    // --------------------------------------------------
+    // NETWORK PATCHING
+    // --------------------------------------------------
     this.patchNetwork();
 
     if (this.debug) {
-      console.log(`[Dropout] 🟢 Online | Project: ${this.projectId}`);
+      console.log(`[Dropout] 🟢 Online | Project ${this.projectId}`);
     }
 
     Dropout.instance = this;
   }
 
-  // -------------------------
-  // Utilities
-  // -------------------------
-  log(msg, ...args) {
-    if (this.debug) console.log(`[Dropout] ${msg}`, ...args);
-  }
-
+  // --------------------------------------------------
+  // UTILITIES
+  // --------------------------------------------------
   generateSessionId() {
     try {
       return crypto.randomUUID();
     } catch {
-      return 'sess_' + Date.now().toString(36);
+      return "sess_" + Date.now().toString(36);
     }
   }
 
   hash(text) {
     if (!text) return null;
     try {
-      return crypto.createHash('sha256')
+      return crypto
+        .createHash("sha256")
         .update(text.toLowerCase().trim())
-        .digest('hex');
+        .digest("hex");
     } catch {
-      return 'hash_err';
+      return "hash_err";
     }
   }
 
-  // -------------------------
-  // Session Context Helpers
-  // -------------------------
-  getSession() {
-    let store = this.ctx.getStore();
+  // --------------------------------------------------
+  // CONTEXT API (OPTIONAL BUT SAFE)
+  // --------------------------------------------------
+  run(sessionId, callback) {
+    if (!this.storage) return callback();
 
-    // 🔑 AUTO-CREATE SESSION IF MISSING
-    if (!store) {
-      store = {
-        session_id: this.generateSessionId(),
-        turn_index: 0,
-        last_prompt_hash: null,
-        last_response_hash: null,
-        last_turn_confirmed: true
-      };
-      this.ctx.enterWith(store);
-    }
+    const context = {
+      sessionId: sessionId || this.generateSessionId(),
+      turnIndex: 0,
+    };
 
-    return store;
+    return this.storage.run(context, callback);
   }
 
-  // -------------------------
-  // AI Detection
-  // -------------------------
+  getContext() {
+    if (!this.storage) return null;
+    return this.storage.getStore() || null;
+  }
+
+  getSessionId() {
+    const ctx = this.getContext();
+    return ctx?.sessionId || "global_session";
+  }
+
+  // --------------------------------------------------
+  // NORMALIZATION
+  // --------------------------------------------------
   normalize(url, body) {
-    let provider = 'custom';
-    let model = 'unknown';
+    let provider = "custom";
+    let model = "unknown";
 
     try {
-      if (url) {
-        const u = url.toLowerCase();
-        if (u.includes('openai')) provider = 'openai';
-        else if (u.includes('anthropic')) provider = 'anthropic';
-        else if (u.includes('google')) provider = 'google';
-        else if (u.includes('groq')) provider = 'groq';
-        else if (u.includes('mistral')) provider = 'mistral';
-        else if (u.includes('cohere')) provider = 'cohere';
-      }
+      const u = url?.toLowerCase() || "";
+      if (u.includes("openai")) provider = "openai";
+      else if (u.includes("anthropic")) provider = "anthropic";
+      else if (u.includes("google")) provider = "google";
+      else if (u.includes("groq")) provider = "groq";
+      else if (u.includes("mistral")) provider = "mistral";
+      else if (u.includes("cohere")) provider = "cohere";
 
       if (body) {
-        const parsed = typeof body === 'string' ? JSON.parse(body) : body;
+        const parsed = typeof body === "string" ? JSON.parse(body) : body;
         if (parsed?.model) model = parsed.model;
       }
     } catch { }
@@ -148,9 +158,8 @@ class Dropout {
   }
 
   isAiRequest(url, body) {
-    if (!url) return false;
-    if (url.includes(this.captureEndpoint)) return false;
-    if (KNOWN_AI_DOMAINS.some(d => url.includes(d))) return true;
+    if (!url || url.includes(this.captureEndpoint)) return false;
+    if (KNOWN_AI_DOMAINS.some((d) => url.includes(d))) return true;
 
     if (body) {
       return (
@@ -158,127 +167,131 @@ class Dropout {
         (body.includes('"messages"') || body.includes('"prompt"'))
       );
     }
-
     return false;
   }
 
-  // -------------------------
-  // Emit
-  // -------------------------
+  // --------------------------------------------------
+  // EMITTER
+  // --------------------------------------------------
   emit(payload) {
     try {
-      const req = (this.captureEndpoint.startsWith('http:') ? http : https)
-        .request(this.captureEndpoint, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'x-dropout-key': this.apiKey
-          }
-        });
-
-      req.on('error', () => { });
-      req.write(JSON.stringify({
+      const finalPayload = {
         project_id: this.projectId,
+        session_id: payload.session_id,
+        turn_index: payload.turn_index,
+        turn_role: payload.turn_role,
+        direction:
+          payload.turn_role === "user" ? "user_to_ai" : "ai_to_user",
+        provider: payload.provider,
+        model: payload.model,
+        latency_ms: payload.latency_ms || null,
+        content: payload.content,
+        content_hash: payload.content_hash,
+        metadata_flags: payload.metadata_flags,
         received_at: new Date().toISOString(),
-        ...payload
-      }));
+      };
+
+      const req = (this.captureEndpoint.startsWith("http:")
+        ? http
+        : https
+      ).request(this.captureEndpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-dropout-key": this.apiKey,
+        },
+      });
+
+      req.on("error", () => { });
+      req.write(JSON.stringify(finalPayload));
       req.end();
     } catch { }
   }
 
-  // -------------------------
-  // Network Patching
-  // -------------------------
+  // --------------------------------------------------
+  // NETWORK PATCHING
+  // --------------------------------------------------
   patchNetwork() {
     const _this = this;
 
-    // ---- FETCH ----
-    if (global.fetch) {
-      const originalFetch = global.fetch;
+    if (!global.fetch) return;
 
-      global.fetch = async function (input, init) {
-        let url;
-        try { url = typeof input === 'string' ? input : input?.url; }
-        catch { return originalFetch.apply(this, arguments); }
+    const originalFetch = global.fetch;
 
-        let bodyStr = '';
-        if (init?.body) {
-          try { bodyStr = typeof init.body === 'string' ? init.body : JSON.stringify(init.body); }
-          catch { }
-        }
+    global.fetch = async function (input, init) {
+      let url;
+      try {
+        url = typeof input === "string" ? input : input?.url;
+      } catch {
+        return originalFetch.apply(this, arguments);
+      }
 
-        if (!_this.isAiRequest(url, bodyStr)) {
-          return originalFetch.apply(this, arguments);
-        }
+      let bodyStr = "";
+      if (init?.body) {
+        try {
+          bodyStr =
+            typeof init.body === "string"
+              ? init.body
+              : JSON.stringify(init.body);
+        } catch { }
+      }
 
-        const session = _this.getSession();
-        const start = Date.now();
-        const { provider, model } = _this.normalize(url, bodyStr);
-        const pHash = _this.hash(bodyStr);
+      if (!_this.isAiRequest(url, bodyStr)) {
+        return originalFetch.apply(this, arguments);
+      }
 
-        const turn =
-          session.last_turn_confirmed
-            ? session.turn_index++
-            : Math.max(session.turn_index - 1, 0);
+      const sessionId = _this.getSessionId();
+      const { provider, model } = _this.normalize(url, bodyStr);
+      const pHash = _this.hash(bodyStr);
+      const start = Date.now();
 
-        session.last_turn_confirmed = false;
+      _this.emit({
+        session_id: sessionId,
+        turn_index: 0,
+        turn_role: "user",
+        provider,
+        model,
+        content: _this.privacy === "full" ? bodyStr : null,
+        content_hash: pHash,
+        metadata_flags: { method: "FETCH", url },
+      });
+
+      const response = await originalFetch.apply(this, arguments);
+
+      try {
+        const cloned = response.clone();
+        let oText = await cloned.text();
+        if (oText.length > _this.maxOutputBytes) {
+          oText = oText.slice(0, _this.maxOutputBytes);
+        }
 
         _this.emit({
-          session_id: session.session_id,
-          turn_index: turn,
-          turn_role: 'user',
-          direction: 'user_to_ai',
+          session_id: sessionId,
+          turn_index: 1,
+          turn_role: "assistant",
+          latency_ms: Date.now() - start,
           provider,
           model,
-          content: _this.privacy === 'full' ? bodyStr : null,
-          content_hash: pHash,
-          metadata_flags: {
-            retry_like: pHash === session.last_prompt_hash ? 1 : 0
-          }
+          content: _this.privacy === "full" ? oText : null,
+          content_hash: _this.hash(oText),
+          metadata_flags: { status: response.status },
         });
+      } catch { }
 
-        session.last_prompt_hash = pHash;
-
-        const response = await originalFetch.apply(this, arguments);
-        const latency = Date.now() - start;
-
-        try {
-          const text = await response.clone().text();
-          const oHash = _this.hash(text);
-
-          _this.emit({
-            session_id: session.session_id,
-            turn_index: turn,
-            turn_role: 'assistant',
-            direction: 'ai_to_user',
-            provider,
-            model,
-            latency_ms: latency,
-            content: _this.privacy === 'full' ? text.slice(0, _this.maxOutputBytes) : null,
-            content_hash: oHash,
-            metadata_flags: {
-              non_adaptive_response: oHash === session.last_response_hash ? 1 : 0,
-              turn_boundary_confirmed: 1,
-              status: response.status
-            }
-          });
-
-          session.last_response_hash = oHash;
-          session.last_turn_confirmed = true;
-        } catch { }
-
-        return response;
-      };
-    }
+      return response;
+    };
   }
 }
 
-// Auto-init
-if (process?.env?.DROPOUT_PROJECT_ID && process?.env?.DROPOUT_API_KEY) {
+// Auto-init via env (safe)
+if (
+  typeof process !== "undefined" &&
+  process.env.DROPOUT_PROJECT_ID &&
+  process.env.DROPOUT_API_KEY
+) {
   Dropout.init({
     projectId: process.env.DROPOUT_PROJECT_ID,
     apiKey: process.env.DROPOUT_API_KEY,
-    debug: process.env.DROPOUT_DEBUG === 'true'
   });
 }