@dropout-ai/runtime 0.1.0

package/README.md

@@ -0,0 +1,36 @@
+# @dropout-ai/runtime
+
+The invisible Node.js sensor for AI observability.
+
+## Overview
+
+`@dropout-ai/runtime` is a zero-dependency, fire-and-forget telemetry sensor that automatically captures OpenAI API interactions from your Node.js or Next.js application.
+
+## Installation
+
+```bash
+npm install @dropout-ai/runtime
+```
+
+## Usage
+
+Simply import the package at the very top of your application's entry point (e.g., `index.js` or `instrumentation.ts`):
+
+```javascript
+import "@dropout-ai/runtime";
+```
+
+Once imported, it automatically:
+1.  Patches `global.fetch`.
+2.  Detects OpenAI API calls.
+3.  Reports telemetry to your local Dropout backend (defaulting to `http://localhost:3000/capture`).
+4.  Fails gracefully and silently without affecting your production traffic.
+
+## Features
+- **Zero Configuration**: Just import and it works.
+- **Invisible capture**: No code changes to your AI logic.
+- **Non-blocking**: Uses fire-and-forget network calls.
+- **Remote Config**: Supports dynamic output capping and provider filtering.
+
+## License
+MIT

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@dropout-ai/runtime",
+  "version": "0.1.0",
+  "description": "Invisible Node.js runtime for capturing AI interactions.",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "openai",
+    "telemetry",
+    "runtime",
+    "invisible"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vaibhavv4re/dropout.git",
+    "directory": "packages/runtime"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Dropout Team",
+  "license": "MIT"
+}

package/src/index.js

@@ -0,0 +1,101 @@
+(function () {
+  // 1. Guard global.fetch existence and idempotency
+  if (typeof global.fetch !== 'function' || global.fetch.__dropout_patched__) {
+    return;
+  }
+
+  const originalFetch = global.fetch;
+
+  // 2. Default Configuration
+  let config = {
+    version: 1,
+    captureOutput: true,
+    maxOutputBytes: 20000,
+    enabledProviders: ['openai']
+  };
+
+  // 3. Remote Config Fetch (Non-blocking, fire-and-forget)
+  setTimeout(async () => {
+    try {
+      const resp = await originalFetch('http://localhost:4000/config');
+      const remoteConfig = await resp.json();
+      if (remoteConfig && typeof remoteConfig === 'object') {
+        config = Object.assign({}, config, remoteConfig);
+      }
+    } catch (e) {
+      // Fail silently, use defaults
+    }
+  }, 0);
+
+  // 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
+    }
+  }
+
+  // 5. The Monkey Patch
+  global.fetch = async function (input, init) {
+    const start = Date.now();
+    const response = await originalFetch(input, init);
+
+    try {
+      // 6. Detection Logic (Dumb detection + Config Check)
+      const url = typeof input === 'string' ? input : (input && input.url);
+      const isAIProvider = config.enabledProviders.some(p => url && url.includes(`${p}.com/v1`));
+
+      if (url && isAIProvider) {
+        const latency = Date.now() - start;
+        const contentType = response.headers.get('content-type') || '';
+        const isStream = contentType.includes('text/event-stream');
+
+        // 7. Safe Body Capture (Best effort)
+        let prompt = undefined;
+        let model = undefined;
+
+        if (init && typeof init.body === 'string') {
+          prompt = init.body;
+          try {
+            const bodyJson = JSON.parse(prompt);
+            model = bodyJson.model;
+          } catch (e) { }
+        }
+
+        let output = undefined;
+        if (!isStream && config.captureOutput) {
+          try {
+            const cloned = response.clone();
+            output = await cloned.text();
+            // 8. Hard Capping (Infra Rule: Trust but verify)
+            if (output && output.length > config.maxOutputBytes) {
+              output = output.slice(0, config.maxOutputBytes);
+            }
+          } catch (e) { }
+        }
+
+        const payload = {
+          provider: 'openai',
+          url,
+          model,
+          prompt,
+          output,
+          latency_ms: latency,
+          timestamp: Math.floor(Date.now() / 1000)
+        };
+
+        // 9. Fire-and-forget
+        setTimeout(() => safeSendTelemetry(payload), 0);
+      }
+    } catch (e) { }
+
+    return response;
+  };
+
+  global.fetch.__dropout_patched__ = true;
+})();