@naylence/agent-sdk 0.3.10 → 0.3.11

package/dist/browser/index.js

@@ -4305,9 +4305,6 @@
     }
 
     const textEncoder$2 = ensureEncoder();
-    const textDecoder$1 = ensureDecoder();
-    const STORAGE_SEED_KEY = 'naylence:fame:seed';
-    let cachedBrowserSeed = null;
     function ensureEncoder() {
         if (typeof TextEncoder !== 'undefined') {
             return new TextEncoder();
@@ -4319,17 +4316,6 @@
         const { TextEncoder: ImportedTextEncoder } = require('util');
         return new ImportedTextEncoder();
     }
-    function ensureDecoder() {
-        if (typeof TextDecoder !== 'undefined') {
-            return new TextDecoder();
-        }
-        const util = globalThis.util;
-        if (util?.TextDecoder) {
-            return new util.TextDecoder();
-        }
-        const { TextDecoder: ImportedTextDecoder } = require('util');
-        return new ImportedTextDecoder();
-    }
     function decodeBase64$2(str) {
         if (typeof atob === 'function') {
             return atob(str);
@@ -4371,111 +4357,34 @@
         }
         return fallbackHash(data);
     }
-    function getCanonicalArgv() {
-        return 'browser';
-    }
-    async function getDefaultBrowserFingerprint(extraMaterial) {
-        const hostFingerprint = `seed:${getStableBrowserSeed()}`;
-        const codeFingerprint = getCanonicalArgv();
-        const parts = [`${hostFingerprint}`, `${codeFingerprint}`];
-        if (extraMaterial !== undefined && extraMaterial !== null) {
-            let salt;
-            if (typeof extraMaterial === 'string') {
-                salt = extraMaterial;
-            }
-            else if (extraMaterial instanceof Uint8Array) {
-                salt = textDecoder$1.decode(extraMaterial);
-            }
-            else {
-                salt = String(extraMaterial);
-            }
-            parts.push(`salt:${salt}`);
-        }
-        const payload = parts.join('|');
-        return textEncoder$2.encode(payload);
-    }
-    function getStableBrowserSeed() {
-        if (cachedBrowserSeed) {
-            return cachedBrowserSeed;
-        }
-        const storages = getWritableStorages();
-        for (const storage of storages) {
-            const stored = readSeed(storage);
-            if (stored) {
-                cachedBrowserSeed = stored;
-                return stored;
-            }
-        }
-        const seed = generateSeed();
-        for (const storage of storages) {
-            if (writeSeed(storage, seed)) {
-                cachedBrowserSeed = seed;
-                return seed;
-            }
-        }
-        cachedBrowserSeed = seed;
-        return seed;
-    }
-    function readSeed(storage) {
-        try {
-            return storage.getItem(STORAGE_SEED_KEY);
-        }
-        catch {
-            return null;
-        }
-    }
-    function writeSeed(storage, seed) {
-        try {
-            storage.setItem(STORAGE_SEED_KEY, seed);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    function getWritableStorages() {
-        const storages = [];
-        const storageNames = [
-            'localStorage',
-            'sessionStorage',
-        ];
-        for (const name of storageNames) {
-            const storage = resolveStorage(name);
-            if (storage) {
-                storages.push(storage);
-            }
-        }
-        return storages;
-    }
-    function resolveStorage(name) {
-        try {
-            const storage = globalThis[name];
-            if (!storage) {
-                return null;
-            }
-            const probeKey = `${STORAGE_SEED_KEY}:probe`;
-            storage.setItem(probeKey, '1');
-            storage.removeItem(probeKey);
-            return storage;
-        }
-        catch {
-            return null;
-        }
-    }
-    function generateSeed() {
-        const bytes = getRandomBytes$1(16);
-        return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
-    }
+    /**
+     * Synchronous ID generation in the browser.
+     *
+     * - mode: "random" → generates a random ID using crypto.getRandomValues when available
+     * - mode: "fingerprint" → falls back to random behavior (fingerprinting requires async)
+     *
+     * Note: In the browser, deterministic fingerprinting requires async operations.
+     * Use generateIdAsync with explicit `material` for deterministic IDs.
+     */
     function generateId(options = {}) {
         const { length = 16, mode = 'random', blacklist = BLACKLIST_ID_WORDS, } = options;
         if (mode !== 'random' && mode !== 'fingerprint') {
             throw new Error("mode must be 'random' or 'fingerprint'");
         }
-        if (mode === 'random') {
-            return generateRandomCandidate(length, getRandomBytes$1, blacklist);
-        }
-        throw new Error('Browser environment requires async ID generation - use generateIdAsync instead');
+        // In the browser, both modes use random generation for the sync API
+        // Fingerprinting requires async operations and explicit material
+        return generateRandomCandidate(length, getRandomBytes$1, blacklist);
     }
+    /**
+     * Asynchronous ID generation in the browser.
+     *
+     * - mode: "random" → generates a random ID using crypto.getRandomValues when available
+     * - mode: "fingerprint" WITH explicit `material` → generates a deterministic ID by hashing the provided material
+     * - mode: "fingerprint" WITHOUT `material` → falls back to random behavior (no implicit fingerprinting)
+     *
+     * Note: This implementation does NOT create browser fingerprints or use localStorage/sessionStorage.
+     * For deterministic IDs, you must explicitly provide `material` in fingerprint mode.
+     */
     async function generateIdAsync(options = {}) {
         const { length = 16, mode = 'random', material, blacklist = BLACKLIST_ID_WORDS, hashAlg = 'sha256', } = options;
         if (mode !== 'random' && mode !== 'fingerprint') {
@@ -4484,14 +4393,13 @@
         if (mode === 'random') {
             return generateRandomCandidate(length, getRandomBytes$1, blacklist);
         }
-        let materialBytes;
+        // Fingerprint mode: only deterministic if material is explicitly provided
         if (material === undefined || material === null) {
-            const envSalt = globalThis.process?.env?.FAME_NODE_ID_SALT;
-            materialBytes = await getDefaultBrowserFingerprint(envSalt ?? '');
-        }
-        else {
-            materialBytes = materialToBytes(material, textEncoder$2);
+            // No implicit fingerprinting - fall back to random
+            return generateRandomCandidate(length, getRandomBytes$1, blacklist);
         }
+        // Deterministic ID generation using explicit material
+        const materialBytes = materialToBytes(material, textEncoder$2);
         const initialDigest = await hashAsync(materialBytes, hashAlg);
         return rehashUntilCleanAsync(initialDigest, length, (input) => hashAsync(input, hashAlg), blacklist);
     }
@@ -15692,12 +15600,12 @@
     // --- END ENV SHIM ---
 
     // This file is auto-generated during build - do not edit manually
-    // Generated from package.json version: 0.3.11
+    // Generated from package.json version: 0.3.12
     /**
      * The package version, injected at build time.
      * @internal
      */
-    const VERSION$1 = '0.3.11';
+    const VERSION$1 = '0.3.12';
 
     /**
      * Fame protocol specific error classes with WebSocket close codes and proper inheritance.
@@ -34612,7 +34520,7 @@
                 }
                 // Use a timeout to prevent hanging during shutdown scenarios
                 // Increased to 1 hour to match server-side keep-alive and prevent idle disconnects
-                const receiveTimeout = 3600000; // 1 hour
+                const receiveTimeout = 30000; // 30 seconds
                 if (this._isFastApiLike && this._websocket.receive_bytes) {
                     // FastAPI-style server WebSocket
                     const receiveMethod = this._websocket.receive_bytes;