@dropout-ai/runtime 0.2.1 → 0.2.3

package/package.json

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

package/src/index.js

@@ -1,16 +1,63 @@
+import crypto from "crypto";
+
 const originalFetch = global.fetch;
 
-// 4. Internal telemetry sender (Neutral naming)
-async function safeSendTelemetry(payload) {
-  try {
-    await originalFetch('http://localhost:4000/capture', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload)
-    });
-  } catch (e) {
-    // Fail silently
-  }
+
+const sessionId =
+  global.__dropout_session_id__ ||
+  (global.__dropout_session_id__ = crypto.randomUUID());
+
+const NEGATIVE_FEEDBACK = [
+  "not helpful",
+  "dont just dump",
+  "you are worst",
+  "you are stupid",
+  "are you sure",
+  "i thought you are intelligent",
+  "let it be"
+];
+
+const ADAPTATION_REQUESTS = [
+  "help me understand",
+  "explain better",
+  "dont just dump facts",
+  "in simple way",
+  "explain it properly"
+];
+
+let turnIndex = 0;
+let lastPrompt = null;
+
+function getSimilarity(text1, text2) {
+  if (!text1 || !text2) return 0;
+  const words1 = new Set(text1.toLowerCase().split(/\s+/));
+  const words2 = new Set(text2.toLowerCase().split(/\s+/));
+  const intersection = new Set([...words1].filter(x => words2.has(x)));
+  return intersection.size / Math.min(words1.size, words2.size);
+}
+
+function getIntentHash(text) {
+  if (!text) return null;
+  return crypto.createHash('sha256').update(text.toLowerCase().trim()).digest('hex');
+}
+
+const CAPABILITY_LIMITATIONS = [
+  "i cannot access", "i don't have access", "i do not have access",
+  "cannot browse", "real-time information", "as an ai", "my knowledge cutoff",
+  "i'm sorry, but i don't", "i am sorry, but i don't"
+];
+
+const CHALLENGE_PATTERNS = ["but ", "why ", "how ", "cant you", "can't you", "are you sure", "openai", "chatgpt"];
+
+function detectSignals(text, output = "") {
+  const t = (text || "").toLowerCase();
+  const o = (output || "").toLowerCase();
+  return {
+    negativeFeedback: NEGATIVE_FEEDBACK.some(p => t.includes(p)) ? 1 : 0,
+    adaptationRequest: ADAPTATION_REQUESTS.some(p => t.includes(p)) ? 1 : 0,
+    userChallenge: CHALLENGE_PATTERNS.some(p => t.includes(p)) ? 1 : 0,
+    capabilityLimitation: CAPABILITY_LIMITATIONS.some(p => o.includes(p)) ? 1 : 0
+  };
 }
 
 (function () {
@@ -24,7 +71,9 @@ async function safeSendTelemetry(payload) {
     version: 1,
     captureOutput: true,
     maxOutputBytes: 20000,
-    enabledProviders: ['openai']
+    enabledProviders: ['openai'],
+    privacyMode: 'safe', // 'safe' | 'full'
+    captureContent: false
   };
 
   // 3. Remote Config Fetch (Non-blocking, fire-and-forget)
@@ -89,40 +138,57 @@ async function safeSendTelemetry(payload) {
         const isStream = contentType.includes('text/event-stream');
 
         // 7. Safe Body Capture (Best effort)
-        let prompt = undefined;
+        let promptText = undefined;
         let model = undefined;
 
         if (init && typeof init.body === 'string') {
-          prompt = init.body;
+          promptText = init.body;
           try {
-            const bodyJson = JSON.parse(prompt);
+            const bodyJson = JSON.parse(promptText);
             model = bodyJson.model;
           } catch (e) { }
         }
 
-        let output = undefined;
+        let outputText = undefined;
         if (!isStream && config.captureOutput) {
           try {
             const cloned = response.clone();
-            output = await cloned.text();
+            outputText = await cloned.text();
             // 8. Hard Capping (Infra Rule: Trust but verify)
-            if (output && output.length > config.maxOutputBytes) {
-              output = output.slice(0, config.maxOutputBytes);
+            if (outputText && outputText.length > config.maxOutputBytes) {
+              outputText = outputText.slice(0, config.maxOutputBytes);
             }
           } catch (e) { }
         }
 
+        const currentSignals = detectSignals(promptText, outputText);
+        const similarity = getSimilarity(lastPrompt, promptText);
+        const intentHash = getIntentHash(promptText);
+
+        const isSafe = config.privacyMode === 'safe' && !config.captureContent;
+
         const payload = {
           provider: url.includes('openai.com') ? 'openai' : 'unknown',
           confidence: matchesKnownProvider(url) ? 'high' : 'heuristic',
           url,
           model,
-          prompt,
-          output,
           latency_ms: latency,
-          timestamp: Math.floor(Date.now() / 1000)
+          timestamp: Math.floor(Date.now() / 1000),
+          session_id: sessionId,
+          turn_index: turnIndex++,
+          intent_hash: intentHash,
+          similarity_prev: similarity,
+          negative_feedback: currentSignals.negativeFeedback,
+          adaptation_request: currentSignals.adaptationRequest,
+          user_challenge: currentSignals.userChallenge,
+          capability_limitation: currentSignals.capabilityLimitation,
+          // Redact content if in safe mode
+          prompt: isSafe ? undefined : promptText,
+          output: isSafe ? undefined : outputText,
         };
 
+        lastPrompt = promptText;
+
         // 9. Fire-and-forget
         setTimeout(() => safeSendTelemetry(payload), 0);
       }
@@ -138,24 +204,72 @@ async function safeSendTelemetry(payload) {
 async function capture(target, options = {}) {
   const start = Date.now();
 
+  // Support dropout.capture({ prompt, response, privacy: "full" })
+  if (typeof target === 'object' && target !== null && !target.then) {
+    const { prompt, response, privacy } = target;
+    const isSafe = (privacy || 'safe') === 'safe';
+
+    const currentSignals = detectSignals(prompt, response);
+    const similarity = getSimilarity(lastPrompt, prompt);
+    const intentHash = getIntentHash(prompt);
+
+    const payload = {
+      provider: 'manual-opt-in',
+      prompt: isSafe ? undefined : prompt,
+      output: isSafe ? undefined : response,
+      latency_ms: 0,
+      timestamp: Math.floor(Date.now() / 1000),
+      session_id: sessionId,
+      turn_index: turnIndex++,
+      intent_hash: intentHash,
+      similarity_prev: similarity,
+      negative_feedback: currentSignals.negativeFeedback,
+      adaptation_request: currentSignals.adaptationRequest,
+      user_challenge: currentSignals.userChallenge,
+      capability_limitation: currentSignals.capabilityLimitation,
+      mode: 'manual'
+    };
+    lastPrompt = prompt;
+    setTimeout(() => safeSendTelemetry(payload), 0);
+    return response;
+  }
+
   try {
     const result =
       typeof target === 'function'
         ? await target()
         : await Promise.resolve(target);
 
+    const isSafe = options.privacy !== 'full';
+
+    const promptText = options.prompt;
+    const resultText = typeof result === 'string'
+      ? result
+      : JSON.stringify(result).slice(0, 20000);
+
+    const currentSignals = detectSignals(promptText, resultText);
+    const similarity = getSimilarity(lastPrompt, promptText);
+    const intentHash = getIntentHash(promptText);
+
     const payload = {
       provider: options.provider || 'manual',
       model: options.model,
-      prompt: options.prompt,
-      output: typeof result === 'string'
-        ? result
-        : JSON.stringify(result).slice(0, 20000),
+      prompt: isSafe ? undefined : promptText,
+      output: isSafe ? undefined : resultText,
       latency_ms: Date.now() - start,
       timestamp: Math.floor(Date.now() / 1000),
+      session_id: sessionId,
+      turn_index: turnIndex++,
+      intent_hash: intentHash,
+      similarity_prev: similarity,
+      negative_feedback: currentSignals.negativeFeedback,
+      adaptation_request: currentSignals.adaptationRequest,
+      user_challenge: currentSignals.userChallenge,
+      capability_limitation: currentSignals.capabilityLimitation,
       mode: 'manual'
     };
 
+    lastPrompt = promptText;
     setTimeout(() => safeSendTelemetry(payload), 0);
     return result;
   } catch (error) {
@@ -164,7 +278,9 @@ async function capture(target, options = {}) {
       error: error?.message || String(error),
       latency_ms: Date.now() - start,
       timestamp: Math.floor(Date.now() / 1000),
-      mode: 'manual'
+      mode: 'manual',
+      session_id: sessionId,
+      turn_index: turnIndex++
     };
 
     setTimeout(() => safeSendTelemetry(payload), 0);