@dropout-ai/runtime 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dropout-ai/runtime",
-  "version": "0.5.0",
+  "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,441 +1,299 @@
 /**
  * @dropout-ai/runtime
  * Universal AI Interaction Capture for Node.js
- * Stability: High (Browser-Safe, Silent Failures)
- * Features: Auto-Discovery, Connectivity Check, Dual-Schema Support
+ * Stability: High (Browser-Safe, Next.js Safe)
  */
 
 let https, http, crypto;
 
 // --- DEFAULT CONFIGURATION ---
-const SUPABASE_FUNCTION_URL = "https://hipughmjlwmwjxzyxfzs.supabase.co/functions/v1/capture-sealed";
+const SUPABASE_FUNCTION_URL =
+  "https://hipughmjlwmwjxzyxfzs.supabase.co/functions/v1/capture-sealed";
 
 // 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 {
-  // Singleton Instance Storage
   static instance = null;
 
-  /**
-   * Universal Initialization Method (Idempotent)
-   * Users call this explicitly in their code.
-   */
   static init(config) {
-    if (!Dropout.instance) {
-      new Dropout(config);
-    }
+    if (!Dropout.instance) new Dropout(config);
     return Dropout.instance;
   }
 
   constructor(config = {}) {
-    // 🛡️ SINGLETON GUARD (Prevent multiple initializations)
-    if (Dropout.instance) {
-      if (config.debug) console.log("[Dropout] ℹ️ Already initialized. Returning existing instance.");
-      return Dropout.instance;
-    }
+    if (Dropout.instance) return Dropout.instance;
 
-    // 🛡️ 1. BROWSER GUARD (Client-Side Protection)
-    if (typeof window !== 'undefined' && typeof window.document !== 'undefined') {
-      if (config.debug) console.warn("[Dropout] ⚠️ Skipped: Browser detected. SDK is Server-Only.");
+    // 🛡️ Browser Guard (prevents client execution)
+    if (typeof window !== "undefined" && typeof window.document !== "undefined") {
       return;
     }
 
-    // 🛡️ 2. CREDENTIAL GUARD
+    // 🛡️ Credential Guard
     if (!config.apiKey || !config.projectId) {
       if (config.debug) {
-        console.warn("\x1b[31m%s\x1b[0m", "[Dropout] 🔴 Initialization Failed: Missing API Key or Project ID.");
+        console.warn("[Dropout] Missing API Key or Project ID");
       }
       return;
     }
 
-    // 🛡️ 3. DEPENDENCY CHECK
     try {
-      https = require('https');
-      http = require('http');
-      crypto = require('crypto');
-    } catch (e) {
-      if (config.debug) console.warn("[Dropout] ⚠️ Skipped: Node core modules missing.");
+      https = require("https");
+      http = require("http");
+      crypto = require("crypto");
+    } catch {
       return;
     }
 
-    // --- INITIALIZATION ---
-    try {
-      this.config = config;
-      this.projectId = config.projectId;
-      this.apiKey = config.apiKey;
-      this.debug = config.debug || false;
-      this.privacy = config.privacy || 'full';
-      this.captureEndpoint = config.captureEndpoint || SUPABASE_FUNCTION_URL;
-      this.maxOutputBytes = 32768;
-
-      // State
-      this.turnIndex = 0;
-      this.lastTurnConfirmed = true;
-      this.lastPromptHash = null;
-      this.lastResponseHash = null;
-
-      // Global Guard (Extra safety for HMR environments like Next.js)
-      if (global.__dropout_initialized__) {
-        if (this.debug) console.log("[Dropout] ℹ️ Global flag found. Skipping re-initialization.");
-        Dropout.instance = this; // Re-bind if lost
-        return;
-      }
-      global.__dropout_initialized__ = true;
-
-      // ✅ Session Identity (Instance-Level, Not Global)
-      // Accept session_id from config OR generate a default
-      // Host app controls session lifecycle via startNewSession()
-      this.currentSessionId = config.sessionId || this.generateSessionId();
-
-      // ✅ VISUAL SUCCESS INDICATOR
-      if (this.debug) {
-        console.log('\x1b[32m%s\x1b[0m', `[Dropout] 🟢 Online | Project: ${this.projectId}`);
-      }
+    this.projectId = config.projectId;
+    this.apiKey = config.apiKey;
+    this.debug = config.debug || false;
+    this.privacy = config.privacy || "full";
+    this.captureEndpoint = config.captureEndpoint || SUPABASE_FUNCTION_URL;
+    this.maxOutputBytes = 32768;
 
-      // Bindings
-      this.log = this.log.bind(this);
-      this.emit = this.emit.bind(this);
+    // --------------------------------------------------
+    // ✅ ASYNC CONTEXT (LAZY, NODE-ONLY)
+    // --------------------------------------------------
+    this.storage = null;
 
-      // 4. Start Network Interceptor
-      this.patchNetwork();
+    try {
+      const asyncHooks = require("async_hooks");
+      this.storage = new asyncHooks.AsyncLocalStorage();
+    } catch {
+      // Edge / Browser / Unsupported — safely disabled
+      this.storage = null;
+    }
 
-      // Lock the instance
-      Dropout.instance = this;
+    // --------------------------------------------------
+    // NETWORK PATCHING
+    // --------------------------------------------------
+    this.patchNetwork();
 
-    } catch (err) {
-      // THE ULTIMATE CATCH-ALL: Ensure app NEVER crashes
-      if (config.debug) console.error("[Dropout] ❌ Initialization Error:", err);
+    if (this.debug) {
+      console.log(`[Dropout] 🟢 Online | Project ${this.projectId}`);
     }
-  }
 
-  // --- UTILS ---
-  log(msg, ...args) {
-    if (this.debug) console.log(`[Dropout] ${msg}`, ...args);
+    Dropout.instance = this;
   }
 
+  // --------------------------------------------------
+  // UTILITIES
+  // --------------------------------------------------
   generateSessionId() {
     try {
       return crypto.randomUUID();
-    } catch (e) {
-      return 'sess_' + Math.random().toString(36).substring(2, 12) + Date.now().toString(36);
-    }
-  }
-
-  /**
-   * 🔑 START NEW SESSION
-   * Call this when user clicks "New Chat" or starts a new conversation thread.
-   * Resets turn counter and generates a fresh session_id.
-   * @param {string} [customSessionId] - Optional custom session ID, otherwise auto-generates
-   * @returns {string} The new session ID
-   */
-  startNewSession(customSessionId) {
-    this.currentSessionId = customSessionId || this.generateSessionId();
-    this.turnIndex = 0; // Reset turn counter for new session
-    this.lastTurnConfirmed = true;
-    this.lastPromptHash = null;
-    this.lastResponseHash = null;
-    if (this.debug) {
-      console.log(`[Dropout] 🔄 New Session Started: ${this.currentSessionId}`);
+    } catch {
+      return "sess_" + Date.now().toString(36);
     }
-    return this.currentSessionId;
   }
 
   hash(text) {
     if (!text) return null;
     try {
-      return crypto.createHash('sha256').update(text.toLowerCase().trim()).digest('hex');
-    } catch (e) { return 'hash_err'; }
+      return crypto
+        .createHash("sha256")
+        .update(text.toLowerCase().trim())
+        .digest("hex");
+    } catch {
+      return "hash_err";
+    }
+  }
+
+  // --------------------------------------------------
+  // CONTEXT API (OPTIONAL BUT SAFE)
+  // --------------------------------------------------
+  run(sessionId, callback) {
+    if (!this.storage) return callback();
+
+    const context = {
+      sessionId: sessionId || this.generateSessionId(),
+      turnIndex: 0,
+    };
+
+    return this.storage.run(context, callback);
+  }
+
+  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') || u.includes('gemini') || u.includes('aiplatform')) provider = 'google';
-        else if (u.includes('groq')) provider = 'groq';
-        else if (u.includes('mistral')) provider = 'mistral';
-        else if (u.includes('cohere')) provider = 'cohere';
-        else if (u.includes('localhost') || u.includes('127.0.0.1')) provider = 'local';
-      }
+      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;
-        if (parsed.model) model = parsed.model;
-        if (provider === 'custom' && (parsed.messages || parsed.prompt)) provider = 'heuristic';
+        const parsed = typeof body === "string" ? JSON.parse(body) : body;
+        if (parsed?.model) model = parsed.model;
       }
-    } catch (e) { }
+    } catch { }
+
     return { provider, model };
   }
 
-  isAiRequest(url, bodyString) {
-    if (!url) return false;
-    if (url.includes(this.captureEndpoint)) return false;
-    if (KNOWN_AI_DOMAINS.some(d => url.includes(d))) return true;
-    if (bodyString) {
-      return (bodyString.includes('"model"') || bodyString.includes('"messages"')) &&
-        (bodyString.includes('"user"') || bodyString.includes('"prompt"'));
+  isAiRequest(url, body) {
+    if (!url || url.includes(this.captureEndpoint)) return false;
+    if (KNOWN_AI_DOMAINS.some((d) => url.includes(d))) return true;
+
+    if (body) {
+      return (
+        body.includes('"model"') &&
+        (body.includes('"messages"') || body.includes('"prompt"'))
+      );
     }
     return false;
   }
 
-  // --- EMITTER ---
+  // --------------------------------------------------
+  // EMITTER
+  // --------------------------------------------------
   emit(payload) {
     try {
-      if (!this.apiKey || !this.projectId) return;
-
       const finalPayload = {
         project_id: this.projectId,
         session_id: payload.session_id,
         turn_index: payload.turn_index,
         turn_role: payload.turn_role,
-        // ✅ DIRECTION LOGIC APPLIED HERE
-        direction: payload.turn_role === 'user' ? 'user_to_ai' : 'ai_to_user',
+        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()
+        received_at: new Date().toISOString(),
       };
 
-      this.log(`🚀 Sending Capture [${payload.turn_role}]`);
-
-      const isHttp = this.captureEndpoint.startsWith('http:');
-      const requestModule = isHttp ? http : https;
-
-      const req = requestModule.request(this.captureEndpoint, {
-        method: 'POST',
+      const req = (this.captureEndpoint.startsWith("http:")
+        ? http
+        : https
+      ).request(this.captureEndpoint, {
+        method: "POST",
         headers: {
-          'Content-Type': 'application/json',
-          'x-dropout-key': this.apiKey
-        }
+          "Content-Type": "application/json",
+          "x-dropout-key": this.apiKey,
+        },
       });
 
-      req.on('error', (e) => this.log("❌ Upload Failed (Silent)", e.message));
+      req.on("error", () => { });
       req.write(JSON.stringify(finalPayload));
       req.end();
-    } catch (e) {
-      this.log("⚠️ Emit Error (Silent)", e);
-    }
+    } catch { }
   }
 
-  // --- CORE PATCHING ---
+  // --------------------------------------------------
+  // NETWORK PATCHING
+  // --------------------------------------------------
   patchNetwork() {
     const _this = this;
 
-    // --- A. PATCH FETCH ---
-    if (global.fetch) {
-      const originalFetch = global.fetch;
-      global.fetch = async function (input, init) {
-        let url;
-        try { url = typeof input === 'string' ? input : input?.url; } catch (e) { return originalFetch.apply(this, arguments); }
-
-        let bodyStr = "";
-        if (init && init.body) {
-          try { bodyStr = typeof init.body === 'string' ? init.body : JSON.stringify(init.body); } catch (e) { }
-        }
+    if (!global.fetch) return;
 
-        if (!_this.isAiRequest(url, bodyStr)) {
-          return originalFetch.apply(this, arguments);
-        }
+    const originalFetch = global.fetch;
 
-        _this.log(`⚡ [FETCH] Intercepting: ${url}`);
-        const start = Date.now();
-
-        let activeTurn;
-        if (_this.lastTurnConfirmed) {
-          activeTurn = _this.turnIndex++;
-          _this.lastTurnConfirmed = false;
-        } else {
-          activeTurn = _this.turnIndex > 0 ? _this.turnIndex - 1 : 0;
-        }
-
-        const { provider, model } = _this.normalize(url, bodyStr);
-        const pHash = _this.hash(bodyStr);
-
-        _this.emit({
-          session_id: _this.currentSessionId,
-          turn_index: activeTurn,
-          turn_role: 'user',
-          provider,
-          model,
-          content: _this.privacy === 'full' ? bodyStr : null,
-          content_hash: pHash,
-          metadata_flags: { retry_like: pHash === _this.lastPromptHash ? 1 : 0, method: 'FETCH', url: url }
-        });
-        _this.lastPromptHash = pHash;
+    global.fetch = async function (input, init) {
+      let url;
+      try {
+        url = typeof input === "string" ? input : input?.url;
+      } catch {
+        return originalFetch.apply(this, arguments);
+      }
 
-        let response;
+      let bodyStr = "";
+      if (init?.body) {
         try {
-          response = await originalFetch.apply(this, arguments);
-        } catch (err) { throw err; }
+          bodyStr =
+            typeof init.body === "string"
+              ? init.body
+              : JSON.stringify(init.body);
+        } catch { }
+      }
 
-        const latency = Date.now() - start;
+      if (!_this.isAiRequest(url, bodyStr)) {
+        return originalFetch.apply(this, arguments);
+      }
 
-        try {
-          const cloned = response.clone();
-          let oText = await cloned.text();
-          if (oText && oText.length > _this.maxOutputBytes) oText = oText.slice(0, _this.maxOutputBytes);
-          const oHash = _this.hash(oText);
-
-          _this.emit({
-            session_id: _this.currentSessionId,
-            turn_index: activeTurn,
-            turn_role: 'assistant',
-            latency_ms: latency,
-            provider,
-            model,
-            content: _this.privacy === 'full' ? oText : null,
-            content_hash: oHash,
-            metadata_flags: {
-              non_adaptive_response: oHash === _this.lastResponseHash ? 1 : 0,
-              turn_boundary_confirmed: 1,
-              status: response.status
-            }
-          });
-          _this.lastResponseHash = oHash;
-          _this.lastTurnConfirmed = true;
-        } catch (e) { _this.log("⚠️ Failed to read response body"); }
-
-        return response;
-      };
-      this.log("✅ Patch Applied: global.fetch");
-    }
+      const sessionId = _this.getSessionId();
+      const { provider, model } = _this.normalize(url, bodyStr);
+      const pHash = _this.hash(bodyStr);
+      const start = Date.now();
+
+      _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 },
+      });
 
-    // --- B. PATCH NODE HTTP/HTTPS ---
-    const patchNodeRequest = (module, moduleName) => {
-      const originalRequest = module.request;
-      module.request = function (...args) {
-        let url;
-        try {
-          if (typeof args[0] === 'string') {
-            url = args[0];
-          } else {
-            const opts = args[0] || {};
-            const protocol = opts.protocol || (moduleName === 'https' ? 'https:' : 'http:');
-            const host = opts.hostname || opts.host || 'localhost';
-            const path = opts.path || '/';
-            url = `${protocol}//${host}${path}`;
-          }
-        } catch (e) { return originalRequest.apply(this, args); }
-
-        if (!_this.isAiRequest(url, null)) {
-          return originalRequest.apply(this, args);
+      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.log(`⚡ [${moduleName.toUpperCase()}] Intercepting: ${url}`);
-        const start = Date.now();
-
-        const clientRequest = originalRequest.apply(this, args);
-        const reqChunks = [];
-        const originalWrite = clientRequest.write;
-        const originalEnd = clientRequest.end;
-
-        clientRequest.write = function (...writeArgs) {
-          try {
-            const chunk = writeArgs[0];
-            if (chunk && (typeof chunk === 'string' || Buffer.isBuffer(chunk))) {
-              reqChunks.push(Buffer.from(chunk));
-            }
-          } catch (e) { }
-          return originalWrite.apply(this, writeArgs);
-        };
-
-        clientRequest.end = function (...endArgs) {
-          try {
-            const chunk = endArgs[0];
-            if (chunk && (typeof chunk === 'string' || Buffer.isBuffer(chunk))) {
-              reqChunks.push(Buffer.from(chunk));
-            }
-
-            const reqBody = Buffer.concat(reqChunks).toString('utf8');
-            const { provider, model } = _this.normalize(url, reqBody);
-            const pHash = _this.hash(reqBody);
-
-            let activeTurn;
-            if (_this.lastTurnConfirmed) {
-              activeTurn = _this.turnIndex++;
-              _this.lastTurnConfirmed = false;
-            } else {
-              activeTurn = _this.turnIndex > 0 ? _this.turnIndex - 1 : 0;
-            }
-
-            clientRequest._dropout_turn = activeTurn;
-            clientRequest._dropout_provider = provider;
-            clientRequest._dropout_model = model;
-
-            _this.emit({
-              session_id: _this.currentSessionId,
-              turn_index: activeTurn,
-              turn_role: 'user',
-              provider,
-              model,
-              content: _this.privacy === 'full' ? reqBody : null,
-              content_hash: pHash,
-              metadata_flags: { retry_like: pHash === _this.lastPromptHash ? 1 : 0, method: moduleName.toUpperCase(), url: url }
-            });
-            _this.lastPromptHash = pHash;
-          } catch (e) { _this.log("⚠️ Request Capture Failed"); }
-
-          return originalEnd.apply(this, endArgs);
-        };
-
-        clientRequest.on('response', (res) => {
-          const resChunks = [];
-          res.on('data', (chunk) => resChunks.push(chunk));
-          res.on('end', () => {
-            try {
-              let resBody = Buffer.concat(resChunks).toString('utf8');
-              if (resBody && resBody.length > _this.maxOutputBytes) resBody = resBody.slice(0, _this.maxOutputBytes);
-
-              const latency = Date.now() - start;
-              const oHash = _this.hash(resBody);
-
-              _this.emit({
-                session_id: _this.currentSessionId,
-                turn_index: clientRequest._dropout_turn || 0,
-                turn_role: 'assistant',
-                latency_ms: latency,
-                provider: clientRequest._dropout_provider,
-                model: clientRequest._dropout_model,
-                content: _this.privacy === 'full' ? resBody : null,
-                content_hash: oHash,
-                metadata_flags: { status: res.statusCode, non_adaptive_response: oHash === _this.lastResponseHash ? 1 : 0 }
-              });
-
-              _this.lastResponseHash = oHash;
-              _this.lastTurnConfirmed = true;
-            } catch (e) { _this.log("⚠️ Response Capture Failed"); }
-          });
+        _this.emit({
+          session_id: sessionId,
+          turn_index: 1,
+          turn_role: "assistant",
+          latency_ms: Date.now() - start,
+          provider,
+          model,
+          content: _this.privacy === "full" ? oText : null,
+          content_hash: _this.hash(oText),
+          metadata_flags: { status: response.status },
         });
+      } catch { }
 
-        return clientRequest;
-      };
+      return response;
     };
-
-    patchNodeRequest(https, 'https');
-    patchNodeRequest(http, 'http');
-    this.log("✅ Patch Applied: http/https");
   }
 }
 
-// Auto-Start (Backwards Compatibility & Environment Variable Support)
-if (typeof process !== 'undefined' && 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'
   });
 }
 
-// 🛡️ DUAL EXPORT FIX (Crucial for TypeScript + Require compatibility)
 Dropout.default = Dropout;
-module.exports = Dropout;
+module.exports = Dropout;