@dropout-ai/runtime 0.2.14 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dropout-ai/runtime",
-  "version": "0.2.14",
+  "version": "0.3.1",
   "description": "Invisible Node.js runtime for capturing AI interactions.",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -1,18 +1,28 @@
 /**
  * @dropout-ai/runtime
- * Role: Passive observer.
- * Behavior: Fire-and-forget raw JSON to Supabase.
- * Authentication: None (Public Endpoint).
+ * Universal AI Interaction Capture for Node.js & Next.js
+ * Patches: fetch, http.request, https.request
+ * Capability: Captures Genkit, OpenAI, LangChain, Axios, and standard fetch.
  */
 
+const https = require('https');
+const http = require('http');
 const crypto = require('crypto');
 
 // --- CONFIGURATION ---
-const SUPABASE_FUNCTION_URL = "https://hipughmjlwmwjxzyxfzs.supabase.co/functions/v1/capture-sealed";
-
-// --- Identity & State ---
-const GLOBAL_OBJ = typeof window !== 'undefined' ? window : global;
-
+const KNOWN_AI_DOMAINS = [
+  'api.openai.com',                  // OpenAI
+  'api.anthropic.com',               // Claude
+  'generativelanguage.googleapis.com', // Gemini
+  'aiplatform.googleapis.com',       // Vertex AI (Genkit often uses this)
+  'api.groq.com',                    // Groq
+  'api.mistral.ai',                  // Mistral
+  'api.cohere.ai'                    // Cohere
+];
+
+const DROPOUT_INGEST_URL = "https://hipughmjlwmwjxzyxfzs.supabase.co/functions/v1/capture-sealed";
+
+// --- UTILS ---
 function generateSessionId() {
   try {
     return crypto.randomUUID();
@@ -21,295 +31,209 @@ function generateSessionId() {
   }
 }
 
-if (!GLOBAL_OBJ.__dropout_session_id__) {
-  GLOBAL_OBJ.__dropout_session_id__ = generateSessionId();
-}
-
-let turnIndex = 0;
-let lastTurnConfirmed = true;
-let lastPromptHash = null;
-let lastResponseHash = null;
-
-let config = {
-  maxOutputBytes: 32768,
-  captureEndpoint: SUPABASE_FUNCTION_URL,
-  privacyMode: (typeof process !== 'undefined' && process.env.DROPOUT_PRIVACY_MODE) || 'full'
-};
-
-/**
- * Telemetry Emitter (Non-blocking, Fire-and-forget)
- */
-function emit(payload) {
-  const fetchFn = GLOBAL_OBJ.__dropout_original_fetch__ || GLOBAL_OBJ.fetch;
-  if (typeof fetchFn !== 'function') return;
-
-  setTimeout(() => {
-    fetchFn(config.captureEndpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify(payload),
-      keepalive: true
-    }).catch(() => { });
-  }, 0);
-}
-
-// --- Lifecycle Signals ---
-
-function emitSessionEnd(reason) {
-  if (GLOBAL_OBJ.__dropout_session_ended__) return;
-  GLOBAL_OBJ.__dropout_session_ended__ = true;
-
-  emit({
-    session_id: GLOBAL_OBJ.__dropout_session_id__,
-    turn_index: turnIndex,
-    direction: 'meta',
-    turn_role: 'system',
-    metadata_flags: {
-      session_end: true,
-      end_reason: reason
+class Dropout {
+  constructor(config = {}) {
+    // 1. Validation
+    if (!config.apiKey || !config.projectId) {
+      console.warn("[Dropout] ⚠️ Initialization Skipped: Missing apiKey or projectId.");
+      return;
     }
-  });
-}
-
-// Browser: Navigation/Reload
-if (typeof window !== 'undefined' && window.addEventListener) {
-  window.addEventListener('beforeunload', () => emitSessionEnd('navigation'));
-}
 
-// Node.js: Process Exit
-if (typeof process !== 'undefined' && process.on) {
-  process.on('exit', () => emitSessionEnd('process_exit'));
-  process.on('SIGINT', () => { emitSessionEnd('sigint'); process.exit(); });
-  process.on('SIGTERM', () => { emitSessionEnd('sigterm'); process.exit(); });
-}
-
-// --- Content Utilities ---
-
-function hash(text) {
-  if (!text) return null;
-  try {
-    return crypto.createHash('sha256').update(text.toLowerCase().trim()).digest('hex');
-  } catch (e) {
-    return 'hash_err';
-  }
-}
-
-// --- Provider Normalization ---
+    // 2. Config Setup
+    this.config = config;
+    this.projectId = config.projectId;
+    this.apiKey = config.apiKey;
+    this.debug = config.debug || false; // Toggle this to see logs
+    this.privacy = config.privacy || 'full';
+
+    // 3. Singleton Guard (Prevent double-patching)
+    if (global.__dropout_initialized__) {
+      if (this.debug) console.log("[Dropout] ℹ️ Already initialized. Skipping patch.");
+      return;
+    }
+    global.__dropout_initialized__ = true;
 
-function normalize(url, body) {
-  let provider = 'unknown';
-  let model = 'unknown';
+    // 4. Initialize Identity
+    if (!global.__dropout_session_id__) {
+      global.__dropout_session_id__ = generateSessionId();
+    }
 
-  if (url) {
-    const u = url.toLowerCase();
-    if (u.includes('openai.com')) provider = 'openai';
-    else if (u.includes('anthropic.com')) provider = 'anthropic';
-    else if (u.includes('google.com') || u.includes('generative')) provider = 'google';
-    else if (u.includes('groq.com')) provider = 'groq';
-    else if (u.includes('localhost') || u.includes('127.0.0.1')) provider = 'local';
+    // 5. Start the Wiretap
+    if (this.debug) console.log(`[Dropout] 🟢 Initialized for Project: ${this.projectId}`);
+    this.patchNetwork();
   }
 
-  if (body) {
-    try {
-      const parsed = typeof body === 'string' ? JSON.parse(body) : body;
-      model = parsed.model || model;
-      if (provider === 'unknown' && (parsed.messages || parsed.prompt || parsed.input)) {
-        provider = 'heuristic';
-      }
-    } catch (e) { }
+  log(msg, ...args) {
+    if (this.debug) console.log(`[Dropout] ${msg}`, ...args);
   }
 
-  return { provider, model };
-}
-
-// --- The Monkey Patch ---
-
-if (typeof GLOBAL_OBJ.fetch === 'function' && !GLOBAL_OBJ.fetch.__dropout_patched__) {
-  GLOBAL_OBJ.__dropout_original_fetch__ = GLOBAL_OBJ.fetch;
-
-  GLOBAL_OBJ.fetch = async function (input, init) {
-    const url = typeof input === 'string' ? input : (input && input.url);
+  isAiRequest(url) {
+    if (!url) return false;
+    // Guard: Infinite Loop Prevention (Don't capture our own calls)
+    if (url.includes(DROPOUT_INGEST_URL)) return false;
 
-    // GUARD: Avoid infinite loops
-    if (url && url.includes(config.captureEndpoint)) {
-      return GLOBAL_OBJ.__dropout_original_fetch__(input, init);
-    }
+    // Check against known AI domains
+    return KNOWN_AI_DOMAINS.some(domain => url.includes(domain));
+  }
 
-    const isAI = url && (
-      url.includes('openai.com') ||
-      url.includes('anthropic.com') ||
-      url.includes('generative') ||
-      url.includes('groq.com') ||
-      (init && init.body && (init.body.includes('"model"') || init.body.includes('"messages"')))
-    );
-
-    if (!isAI) return GLOBAL_OBJ.__dropout_original_fetch__(input, init);
-
-    const start = Date.now();
-
-    // --- Explicit Turn Increment Rule ---
-    let activeTurn;
-    if (lastTurnConfirmed) {
-      activeTurn = turnIndex++;
-      lastTurnConfirmed = false;
-    } else {
-      activeTurn = turnIndex > 0 ? turnIndex - 1 : 0;
+  // --- THE CORE: UNIVERSAL PATCHING ---
+  patchNetwork() {
+    const _this = this;
+
+    // A. Patch Global Fetch (Used by OpenAI v4+, Vercel AI SDK, Next.js)
+    if (global.fetch) {
+      const originalFetch = global.fetch;
+      global.fetch = async function (input, init) {
+        const url = typeof input === 'string' ? input : input?.url;
+
+        // PASSTHROUGH: If not AI, ignore
+        if (!_this.isAiRequest(url)) {
+          return originalFetch.apply(this, arguments);
+        }
+
+        _this.log(`⚡ [FETCH] Intercepting request to: ${url}`);
+
+        // Capture Request Body
+        let reqBody = "";
+        try { if (init && init.body) reqBody = init.body; } catch (e) { }
+
+        const startTime = Date.now();
+        let response;
+
+        // Execute Original Call
+        try {
+          response = await originalFetch.apply(this, arguments);
+        } catch (e) { throw e; }
+
+        // Capture Response (Clone response stream)
+        try {
+          const cloned = response.clone();
+          const resBody = await cloned.text();
+
+          _this.emit({
+            url,
+            method: 'FETCH',
+            request: reqBody,
+            response: resBody,
+            latency: Date.now() - startTime,
+            status: response.status
+          });
+        } catch (e) { _this.log("⚠️ Error reading response body", e); }
+
+        return response;
+      };
+      this.log("✅ Patch Applied: global.fetch");
     }
 
-    const { provider, model } = normalize(url, init && init.body);
-
-    // --- 1. Emit Request Event ---
-    let pText = "";
-    if (init && init.body) {
-      try { pText = typeof init.body === 'string' ? init.body : JSON.stringify(init.body); } catch (e) { }
-    }
-    const pHash = hash(pText);
-    const isRetry = pHash && pHash === lastPromptHash;
-
-    const requestEvent = {
-      session_id: GLOBAL_OBJ.__dropout_session_id__,
-      turn_index: activeTurn,
-      direction: 'user_to_ai',
-      turn_role: 'user',
-      provider,
-      model,
-      // FIX: Renamed 'content_raw' to 'content' to match Supabase expectations
-      content: config.privacyMode === 'full' ? pText : null,
-      content_hash: pHash,
-      metadata_flags: {
-        retry_like: isRetry ? 1 : 0
-      }
+    // B. Patch Node HTTPS/HTTP (Used by Axios, Google Vertex SDK, Legacy LangChain)
+    const patchNodeRequest = (module, moduleName) => {
+      const originalRequest = module.request;
+      module.request = function (...args) {
+        // Resolve URL from varied arguments
+        let url;
+        let options;
+        if (typeof args[0] === 'string') {
+          url = args[0];
+          options = args[1] || {};
+        } else {
+          options = args[0] || {};
+          const protocol = options.protocol || 'https:';
+          const host = options.hostname || options.host || 'localhost';
+          const path = options.path || '/';
+          url = `${protocol}//${host}${path}`;
+        }
+
+        // PASSTHROUGH: If not AI, ignore
+        if (!_this.isAiRequest(url)) {
+          return originalRequest.apply(this, args);
+        }
+
+        _this.log(`⚡ [${moduleName.toUpperCase()}] Intercepting request to: ${url}`);
+
+        const startTime = Date.now();
+        const clientRequest = originalRequest.apply(this, args);
+
+        // Capture Request Body (Chunks)
+        const chunks = [];
+        const originalWrite = clientRequest.write;
+        const originalEnd = clientRequest.end;
+
+        clientRequest.write = function (...writeArgs) {
+          if (writeArgs[0]) chunks.push(Buffer.from(writeArgs[0]));
+          return originalWrite.apply(this, writeArgs);
+        };
+
+        clientRequest.end = function (...endArgs) {
+          if (endArgs[0]) chunks.push(Buffer.from(endArgs[0]));
+          // Store full body on the request object for later
+          clientRequest._fullBody = Buffer.concat(chunks).toString('utf8');
+          return originalEnd.apply(this, endArgs);
+        };
+
+        // Capture Response
+        clientRequest.on('response', (res) => {
+          const resChunks = [];
+          res.on('data', (chunk) => resChunks.push(chunk));
+          res.on('end', () => {
+            const resBody = Buffer.concat(resChunks).toString('utf8');
+            _this.emit({
+              url,
+              method: moduleName.toUpperCase(),
+              request: clientRequest._fullBody,
+              response: resBody,
+              latency: Date.now() - startTime,
+              status: res.statusCode
+            });
+          });
+        });
+
+        return clientRequest;
+      };
     };
 
-    emit(requestEvent);
-    lastPromptHash = pHash;
-
-    // Execute actual fetch
-    let response;
-    let oText = "";
-    try {
-      response = await GLOBAL_OBJ.__dropout_original_fetch__(input, init);
-    } catch (err) {
-      throw err;
-    }
-
-    const latency = Date.now() - start;
+    patchNodeRequest(https, 'https');
+    patchNodeRequest(http, 'http');
+    this.log("✅ Patch Applied: http/https");
+  }
 
-    // --- 2. Emit Response Event ---
-    try {
-      const cloned = response.clone();
-      oText = await cloned.text();
-      if (oText && oText.length > config.maxOutputBytes) {
-        oText = oText.slice(0, config.maxOutputBytes);
-      }
-    } catch (e) { }
-
-    const oHash = hash(oText);
-    const isNonAdaptive = oHash && oHash === lastResponseHash;
-
-    const responseEvent = {
-      session_id: GLOBAL_OBJ.__dropout_session_id__,
-      turn_index: activeTurn,
-      direction: 'ai_to_user',
-      turn_role: 'assistant',
-      latency_ms: latency,
-      provider,
-      model,
-      // FIX: Renamed 'content_raw' to 'content'
-      content: config.privacyMode === 'full' ? oText : null,
-      content_hash: oHash,
+  // --- EMITTER ---
+  emit(data) {
+    // 1. Construct Payload
+    // We combine Request + Response into a single content blob for simplicity in this universal mode
+    const content = `--- REQUEST ---\n${data.request}\n\n--- RESPONSE ---\n${data.response}`;
+
+    const payload = {
+      project_id: this.projectId,
+      session_id: global.__dropout_session_id__,
+      turn_role: 'assistant', // Default to assistant for system-captured logs
+      turn_index: 0, // In universal mode, we capture raw streams
+      content_blob: this.privacy === 'full' ? content : null,
       metadata_flags: {
-        non_adaptive_response: isNonAdaptive ? 1 : 0,
-        turn_boundary_confirmed: 1
-      }
+        latency: data.latency,
+        url: data.url,
+        method: data.method,
+        status: data.status,
+        captured_via: 'universal_interceptor'
+      },
+      received_at: new Date().toISOString()
     };
 
-    emit(responseEvent);
-    lastResponseHash = oHash;
-    lastTurnConfirmed = true;
-
-    return response;
-  };
-
-  GLOBAL_OBJ.fetch.__dropout_patched__ = true;
-}
+    this.log(`🚀 Sending Capture to Supabase (${data.latency}ms)`);
 
-/**
- * Manual capture for framework-level integration
- */
-async function capture(target, options = {}) {
-  const start = Date.now();
-
-  let activeTurn;
-  if (lastTurnConfirmed) {
-    activeTurn = turnIndex++;
-    lastTurnConfirmed = false;
-  } else {
-    activeTurn = turnIndex > 0 ? turnIndex - 1 : 0;
-  }
-
-  const mode = options.privacy || config.privacyMode;
-
-  let prompt, output, latency_ms = options.latency || 0;
+    // 2. Fire and Forget (Using unpatched fetch mechanism)
+    // We use a clean http request to avoid triggering our own hooks if we used global.fetch
+    const req = https.request(DROPOUT_INGEST_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-dropout-key': this.apiKey
+      }
+    });
 
-  if (typeof target === 'function' || (target && typeof target.then === 'function')) {
-    prompt = options.prompt;
-    const result = typeof target === 'function' ? await target() : await target;
-    output = typeof result === 'string' ? result : JSON.stringify(result);
-    latency_ms = Date.now() - start;
-  } else {
-    prompt = target.prompt;
-    output = target.output;
+    req.on('error', (e) => this.log("❌ Upload Failed", e.message));
+    req.write(JSON.stringify(payload));
+    req.end();
   }
-
-  const pHash = hash(prompt);
-  const oHash = hash(output);
-
-  // Emit Request
-  emit({
-    session_id: GLOBAL_OBJ.__dropout_session_id__,
-    turn_index: activeTurn,
-    direction: 'user_to_ai',
-    turn_role: 'user',
-    provider: options.provider || 'manual',
-    model: options.model || 'unknown',
-    content: mode === 'full' ? prompt : null, // FIX: content_raw -> content
-    content_hash: pHash,
-    metadata_flags: { retry_like: pHash === lastPromptHash ? 1 : 0 }
-  });
-
-  // Emit Response
-  emit({
-    session_id: GLOBAL_OBJ.__dropout_session_id__,
-    turn_index: activeTurn,
-    direction: 'ai_to_user',
-    turn_role: 'assistant',
-    latency_ms,
-    provider: options.provider || 'manual',
-    model: options.model || 'unknown',
-    content: mode === 'full' ? output : null, // FIX: content_raw -> content
-    content_hash: oHash,
-    metadata_flags: { non_adaptive_response: oHash === lastResponseHash ? 1 : 0, turn_boundary_confirmed: 1 }
-  });
-
-  lastPromptHash = pHash;
-  lastResponseHash = oHash;
-  lastTurnConfirmed = true;
-
-  return output;
 }
 
-module.exports = {
-  capture,
-  reset: (reason = 'manual_reset') => {
-    emitSessionEnd(reason);
-    GLOBAL_OBJ.__dropout_session_id__ = generateSessionId();
-    GLOBAL_OBJ.__dropout_session_ended__ = false;
-    turnIndex = 0;
-    lastTurnConfirmed = true;
-    lastPromptHash = null;
-    lastResponseHash = null;
-  }
-};
+module.exports = Dropout;