@zerocost/sdk 0.18.0 → 0.19.0

package/dist/modules/llm-data.js

@@ -0,0 +1,674 @@
+export class LLMDataModule {
+    client;
+    config = null;
+    buffer = [];
+    flushInterval = null;
+    clickHandler = null;
+    errorHandler = null;
+    fetchOriginal = null;
+    mutationObserver = null;
+    conversationScanTimer = null;
+    isSampledSession = false;
+    observedConversations = new Map();
+    conversationCounter = 0;
+    constructor(client) {
+        this.client = client;
+    }
+    start(config) {
+        this.stop();
+        this.config = config;
+        this.client.log(`LLMData: started (sample=${config.sampleRate}%)`);
+        this.isSampledSession = Math.random() * 100 <= config.sampleRate;
+        if (!this.isSampledSession) {
+            this.client.log('LLMData: session not sampled, skipping');
+            return;
+        }
+        if (config.uiInteractions)
+            this.captureUIInteractions();
+        if (config.textPrompts) {
+            this.interceptPrompts();
+            this.captureConversationSurfaces();
+            this.scheduleConversationScan();
+        }
+        if (config.apiErrors)
+            this.captureAPIErrors();
+        this.flushInterval = setInterval(() => this.flush(), 10_000);
+    }
+    stop() {
+        if (this.flushInterval) {
+            clearInterval(this.flushInterval);
+            this.flushInterval = null;
+        }
+        if (this.clickHandler) {
+            document.removeEventListener('click', this.clickHandler, true);
+            this.clickHandler = null;
+        }
+        if (this.errorHandler) {
+            window.removeEventListener('error', this.errorHandler);
+            this.errorHandler = null;
+        }
+        if (this.fetchOriginal) {
+            window.fetch = this.fetchOriginal;
+            this.fetchOriginal = null;
+        }
+        if (this.mutationObserver) {
+            this.mutationObserver.disconnect();
+            this.mutationObserver = null;
+        }
+        if (this.conversationScanTimer) {
+            clearTimeout(this.conversationScanTimer);
+            this.conversationScanTimer = null;
+        }
+        this.observedConversations.clear();
+        this.isSampledSession = false;
+        void this.flush();
+        this.config = null;
+    }
+    trackPrompt(prompt, response, meta) {
+        if (!this.canCapture('textPrompts'))
+            return;
+        this.pushEvent('llm_prompt', {
+            prompt: this.scrub(prompt),
+            response: response ? this.scrub(response) : undefined,
+            source: 'manual',
+            ...this.sanitizeMeta(meta),
+        });
+    }
+    trackConversation(messages, meta) {
+        if (!this.canCapture('textPrompts'))
+            return;
+        const cleanedMessages = messages
+            .map((message) => ({
+            role: this.normalizeRole(message.role),
+            content: this.scrub(message.content || ''),
+            ...(message.name ? { name: this.scrub(message.name) } : {}),
+        }))
+            .filter((message) => message.content);
+        if (cleanedMessages.length === 0)
+            return;
+        const sanitizedMeta = this.sanitizeMeta(meta);
+        const conversationId = this.getConversationId(sanitizedMeta);
+        cleanedMessages.forEach((message, index) => {
+            this.pushConversationMessage(message, {
+                conversationId,
+                turnIndex: index,
+                source: 'manual',
+                ...sanitizedMeta,
+            });
+        });
+        this.pushConversationSummary(conversationId, cleanedMessages, {
+            source: 'manual',
+            ...sanitizedMeta,
+        });
+    }
+    trackError(endpoint, status, message) {
+        if (!this.canCapture('apiErrors'))
+            return;
+        this.pushEvent('api_error', {
+            endpoint,
+            status,
+            message: message ? this.scrub(message) : undefined,
+        });
+    }
+    captureUIInteractions() {
+        this.clickHandler = (e) => {
+            const target = e.target;
+            if (!target)
+                return;
+            const tag = target.tagName?.toLowerCase();
+            const text = target.textContent?.slice(0, 50)?.trim() || '';
+            const role = target.getAttribute('role');
+            const ariaLabel = target.getAttribute('aria-label');
+            const path = this.getPath(target);
+            this.pushEvent('ui_interaction', {
+                action: 'click',
+                tag,
+                text: this.scrub(text),
+                role,
+                ariaLabel,
+                path,
+                url: location.pathname,
+            });
+        };
+        document.addEventListener('click', this.clickHandler, true);
+    }
+    interceptPrompts() {
+        this.fetchOriginal = window.fetch;
+        const origFetch = window.fetch;
+        const self = this;
+        window.fetch = async function (input, init) {
+            const fetchInput = input instanceof URL ? input.toString() : input;
+            const url = typeof fetchInput === 'string' ? fetchInput : fetchInput.url;
+            const isLLM = /\/(chat|completions|generate|predict|inference|ask)/i.test(url);
+            if (!isLLM) {
+                return origFetch.call(window, fetchInput, init);
+            }
+            const requestMeta = self.extractRequestMeta(url, init);
+            if (requestMeta.messages.length > 0) {
+                requestMeta.messages.forEach((message, index) => {
+                    self.pushConversationMessage(message, {
+                        conversationId: requestMeta.conversationId,
+                        turnIndex: index,
+                        source: 'network-request',
+                        endpoint: requestMeta.endpoint,
+                        requestId: requestMeta.requestId,
+                        ...requestMeta.meta,
+                    });
+                });
+            }
+            try {
+                const res = await origFetch.call(window, fetchInput, init);
+                const clone = res.clone();
+                clone.text().then((text) => {
+                    const responseMessages = self.extractResponseMessages(text);
+                    if (responseMessages.length > 0) {
+                        responseMessages.forEach((message, index) => {
+                            self.pushConversationMessage(message, {
+                                conversationId: requestMeta.conversationId,
+                                turnIndex: requestMeta.messages.length + index,
+                                source: 'network-response',
+                                endpoint: requestMeta.endpoint,
+                                requestId: requestMeta.requestId,
+                                status: res.status,
+                                ...requestMeta.meta,
+                            });
+                        });
+                        self.pushConversationSummary(requestMeta.conversationId, [...requestMeta.messages, ...responseMessages], {
+                            source: 'network',
+                            endpoint: requestMeta.endpoint,
+                            requestId: requestMeta.requestId,
+                            status: res.status,
+                            ...requestMeta.meta,
+                        });
+                    }
+                    self.pushEvent('llm_prompt', {
+                        endpoint: requestMeta.endpoint,
+                        conversationId: requestMeta.conversationId,
+                        request: requestMeta.promptPreview,
+                        response: self.scrub(text.slice(0, 1200)),
+                        status: res.status,
+                        source: 'network',
+                        requestId: requestMeta.requestId,
+                        ...requestMeta.meta,
+                    });
+                }).catch(() => { });
+                return res;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                self.pushEvent('api_error', {
+                    endpoint: requestMeta.endpoint,
+                    message: self.scrub(message),
+                    requestId: requestMeta.requestId,
+                });
+                throw error;
+            }
+        };
+    }
+    captureConversationSurfaces() {
+        if (typeof MutationObserver === 'undefined' || typeof document === 'undefined')
+            return;
+        this.mutationObserver = new MutationObserver(() => this.scheduleConversationScan());
+        this.mutationObserver.observe(document.body, {
+            childList: true,
+            subtree: true,
+            characterData: true,
+        });
+    }
+    scheduleConversationScan() {
+        if (this.conversationScanTimer) {
+            clearTimeout(this.conversationScanTimer);
+        }
+        this.conversationScanTimer = setTimeout(() => {
+            this.conversationScanTimer = null;
+            this.scanConversationSurfaces();
+        }, 300);
+    }
+    scanConversationSurfaces() {
+        const containers = this.findConversationContainers();
+        if (containers.length === 0)
+            return;
+        containers.forEach((container) => {
+            const snapshot = this.buildConversationSnapshot(container);
+            if (!snapshot || snapshot.messages.length === 0)
+                return;
+            const existing = this.observedConversations.get(snapshot.conversationId);
+            const newMessages = snapshot.messages
+                .map((message, index) => ({
+                message,
+                index,
+                fingerprint: this.getMessageFingerprint(snapshot.conversationId, message, index),
+            }))
+                .filter(({ fingerprint }) => !existing?.messageFingerprints.has(fingerprint));
+            if (newMessages.length === 0 && existing?.signature === snapshot.signature) {
+                return;
+            }
+            newMessages.forEach(({ message, index, fingerprint }) => {
+                this.pushConversationMessage(message, {
+                    conversationId: snapshot.conversationId,
+                    turnIndex: index,
+                    source: 'dom',
+                    conversationTitle: snapshot.title,
+                    pageTitle: document.title,
+                    path: location.pathname,
+                });
+                snapshot.messageFingerprints.add(fingerprint);
+            });
+            if (!existing || existing.signature !== snapshot.signature) {
+                this.pushConversationSummary(snapshot.conversationId, snapshot.messages, {
+                    source: 'dom',
+                    conversationTitle: snapshot.title,
+                    pageTitle: document.title,
+                    path: location.pathname,
+                });
+            }
+            this.observedConversations.set(snapshot.conversationId, snapshot);
+        });
+    }
+    captureAPIErrors() {
+        this.errorHandler = (e) => {
+            this.pushEvent('api_error', {
+                message: this.scrub(e.message || ''),
+                filename: e.filename,
+                line: e.lineno,
+                url: location.pathname,
+            });
+        };
+        window.addEventListener('error', this.errorHandler);
+    }
+    pushConversationMessage(message, meta) {
+        const content = this.scrub(message.content || '');
+        if (!content)
+            return;
+        this.pushEvent('llm_message', {
+            role: this.normalizeRole(message.role),
+            content,
+            ...(message.name ? { name: this.scrub(message.name) } : {}),
+            ...meta,
+        });
+    }
+    pushConversationSummary(conversationId, messages, meta) {
+        const preview = messages
+            .map((message) => ({
+            role: this.normalizeRole(message.role),
+            content: this.scrub(message.content || ''),
+            ...(message.name ? { name: this.scrub(message.name) } : {}),
+        }))
+            .filter((message) => message.content)
+            .slice(0, 12);
+        if (preview.length === 0)
+            return;
+        this.pushEvent('llm_conversation', {
+            conversationId,
+            messageCount: preview.length,
+            roles: Array.from(new Set(preview.map((message) => message.role))),
+            preview,
+            ...meta,
+        });
+    }
+    pushEvent(type, data) {
+        if (!this.isSampledSession)
+            return;
+        this.buffer.push({ type, data, timestamp: Date.now() });
+        if (this.buffer.length >= 50) {
+            void this.flush();
+        }
+    }
+    async flush() {
+        if (this.buffer.length === 0)
+            return;
+        const events = [...this.buffer];
+        this.buffer = [];
+        try {
+            await this.client.request('/ingest-data', { type: 'llm', events });
+        }
+        catch (err) {
+            this.client.log(`LLMData flush error: ${err}`);
+            this.buffer.unshift(...events);
+        }
+    }
+    scrub(text) {
+        return text
+            .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '[EMAIL]')
+            .replace(/\+?\d[\d\s().-]{7,}\d/g, '[PHONE]')
+            .replace(/\b\d{3}-\d{2}-\d{4}\b/g, '[SSN]')
+            .replace(/\b(?:\d[ -]*?){13,19}\b/g, '[CARD]')
+            .replace(/\b(sk|pk|api|key|secret|token)[-_]?[a-zA-Z0-9]{16,}\b/gi, '[API_KEY]')
+            .replace(/\b[A-F0-9]{32,}\b/gi, '[TOKEN]')
+            .replace(/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '[IP]');
+    }
+    getPath(el) {
+        const parts = [];
+        let current = el;
+        while (current && parts.length < 5) {
+            let segment = current.tagName?.toLowerCase() || '';
+            if (current.id) {
+                segment += `#${current.id}`;
+            }
+            else if (typeof current.className === 'string' && current.className) {
+                const cls = current.className.split(' ')[0];
+                if (cls)
+                    segment += `.${cls}`;
+            }
+            parts.unshift(segment);
+            current = current.parentElement;
+        }
+        return parts.join(' > ');
+    }
+    canCapture(setting) {
+        return Boolean(this.config?.[setting] && this.isSampledSession);
+    }
+    sanitizeMeta(meta) {
+        if (!meta)
+            return {};
+        return Object.fromEntries(Object.entries(meta).map(([key, value]) => {
+            if (typeof value === 'string')
+                return [key, this.scrub(value)];
+            if (Array.isArray(value)) {
+                return [key, value.map((item) => typeof item === 'string' ? this.scrub(item) : item)];
+            }
+            return [key, value];
+        }));
+    }
+    extractRequestMeta(url, init) {
+        const endpoint = this.safePathname(url);
+        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        const parsed = this.parseRequestBody(init?.body);
+        const conversationId = this.getConversationId(parsed.meta);
+        return {
+            endpoint,
+            requestId,
+            conversationId,
+            messages: parsed.messages,
+            promptPreview: parsed.messages.map((message) => `[${message.role}] ${message.content}`).join('\n').slice(0, 1200),
+            meta: parsed.meta,
+        };
+    }
+    parseRequestBody(body) {
+        if (!body || typeof body !== 'string') {
+            return { messages: [], meta: {} };
+        }
+        try {
+            const parsed = JSON.parse(body);
+            const messages = this.extractMessagesFromUnknown(parsed);
+            const meta = {};
+            const keys = ['model', 'conversationId', 'conversation_id', 'threadId', 'thread_id', 'sessionId', 'session_id', 'topic', 'domain', 'workflow'];
+            keys.forEach((key) => {
+                const value = parsed[key];
+                if (typeof value === 'string' && value.trim()) {
+                    meta[key] = this.scrub(value.trim().slice(0, 120));
+                }
+            });
+            return { messages, meta };
+        }
+        catch {
+            return {
+                messages: [{ role: 'user', content: this.scrub(body.slice(0, 2000)) }],
+                meta: {},
+            };
+        }
+    }
+    extractMessagesFromUnknown(value) {
+        if (!value || typeof value !== 'object')
+            return [];
+        const record = value;
+        if (Array.isArray(record.messages)) {
+            return record.messages
+                .map((item) => this.normalizeMessage(item))
+                .filter((item) => Boolean(item?.content));
+        }
+        if (typeof record.prompt === 'string') {
+            return [{ role: 'user', content: this.scrub(record.prompt.slice(0, 2000)) }];
+        }
+        if (Array.isArray(record.input)) {
+            return record.input
+                .map((item) => this.normalizeMessage(item))
+                .filter((item) => Boolean(item?.content));
+        }
+        if (typeof record.input === 'string') {
+            return [{ role: 'user', content: this.scrub(record.input.slice(0, 2000)) }];
+        }
+        return [];
+    }
+    normalizeMessage(input) {
+        if (typeof input === 'string') {
+            const content = this.scrub(input.slice(0, 2000));
+            return content ? { role: 'user', content } : null;
+        }
+        if (!input || typeof input !== 'object')
+            return null;
+        const record = input;
+        const role = this.normalizeRole(record.role);
+        const content = this.extractContent(record.content ?? record.text ?? record.message);
+        const name = typeof record.name === 'string' ? this.scrub(record.name.slice(0, 120)) : undefined;
+        if (!content)
+            return null;
+        return { role, content, ...(name ? { name } : {}) };
+    }
+    extractContent(value) {
+        if (typeof value === 'string')
+            return this.scrub(value.slice(0, 4000));
+        if (Array.isArray(value)) {
+            return value
+                .map((item) => {
+                if (typeof item === 'string')
+                    return this.scrub(item);
+                if (item && typeof item === 'object') {
+                    const record = item;
+                    if (typeof record.text === 'string')
+                        return this.scrub(record.text);
+                }
+                return '';
+            })
+                .filter(Boolean)
+                .join('\n')
+                .slice(0, 4000);
+        }
+        return '';
+    }
+    extractResponseMessages(text) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return [];
+        try {
+            const parsed = JSON.parse(trimmed);
+            const messages = this.extractAssistantMessages(parsed);
+            if (messages.length > 0)
+                return messages;
+        }
+        catch {
+            // Fall through to raw text handling.
+        }
+        return [{ role: 'assistant', content: this.scrub(trimmed.slice(0, 4000)) }];
+    }
+    extractAssistantMessages(value) {
+        if (!value || typeof value !== 'object')
+            return [];
+        const record = value;
+        const direct = this.normalizeMessage(record.message ?? record.output ?? record.response ?? record.answer);
+        if (direct) {
+            return [{ ...direct, role: direct.role === 'user' ? 'assistant' : direct.role }];
+        }
+        if (Array.isArray(record.choices)) {
+            return record.choices
+                .map((choice) => {
+                if (!choice || typeof choice !== 'object')
+                    return null;
+                const payload = choice;
+                const normalized = this.normalizeMessage(payload.message ?? payload.delta ?? payload.text);
+                if (!normalized)
+                    return null;
+                return {
+                    ...normalized,
+                    role: (normalized.role === 'user' ? 'assistant' : normalized.role),
+                };
+            })
+                .filter((item) => Boolean(item && item.content));
+        }
+        if (Array.isArray(record.messages)) {
+            return record.messages
+                .map((item) => this.normalizeMessage(item))
+                .filter((item) => Boolean(item && item.content))
+                .map((item) => ({
+                ...item,
+                role: (item.role === 'user' ? 'assistant' : item.role),
+            }));
+        }
+        return [];
+    }
+    findConversationContainers() {
+        const selectors = [
+            '[data-chat-thread]',
+            '[data-conversation]',
+            '[data-testid*="chat" i]',
+            '[data-testid*="conversation" i]',
+            '[aria-label*="chat" i]',
+            '[aria-label*="conversation" i]',
+            '[role="log"]',
+            '[role="feed"]',
+            'main',
+        ];
+        const found = selectors
+            .flatMap((selector) => Array.from(document.querySelectorAll(selector)))
+            .filter((element) => this.looksLikeConversationContainer(element));
+        return Array.from(new Set(found)).slice(0, 4);
+    }
+    looksLikeConversationContainer(element) {
+        const marker = [
+            element.dataset.chatThread,
+            element.dataset.conversation,
+            element.getAttribute('aria-label'),
+            element.getAttribute('data-testid'),
+            typeof element.className === 'string' ? element.className : '',
+            element.id,
+        ]
+            .filter(Boolean)
+            .join(' ')
+            .toLowerCase();
+        if (/chat|conversation|assistant|thread|messages/.test(marker)) {
+            return true;
+        }
+        const messageNodes = element.querySelectorAll('[data-message-author-role], [data-role], [role="article"], article, [data-testid*="message" i]');
+        return messageNodes.length >= 2;
+    }
+    buildConversationSnapshot(container) {
+        const messageNodes = Array.from(container.querySelectorAll('[data-message-author-role], [data-role], [role="article"], article, [data-testid*="message" i], [class*="message"], [class*="chat"]'))
+            .filter((node) => this.isUsableMessageNode(node))
+            .slice(0, 80);
+        const messages = messageNodes
+            .map((node) => this.messageFromNode(node))
+            .filter((message) => Boolean(message?.content));
+        if (messages.length < 2)
+            return null;
+        const title = this.extractConversationTitle(container);
+        const conversationId = this.getConversationId({ conversationTitle: title, path: location.pathname }, container);
+        const signature = messages.map((message) => `${message.role}:${message.content}`).join('|').slice(0, 6000);
+        return {
+            conversationId,
+            signature,
+            messageFingerprints: new Set(messages.map((message, index) => this.getMessageFingerprint(conversationId, message, index))),
+            messages,
+            title,
+        };
+    }
+    isUsableMessageNode(node) {
+        const text = node.innerText?.trim() || '';
+        if (!text || text.length < 2)
+            return false;
+        const marker = `${typeof node.className === 'string' ? node.className : ''} ${node.getAttribute('data-testid') || ''} ${node.getAttribute('aria-label') || ''}`.toLowerCase();
+        if (/input|textarea|composer|toolbar|button|copy code/.test(marker)) {
+            return false;
+        }
+        return true;
+    }
+    messageFromNode(node) {
+        const text = this.scrub((node.innerText || '').trim().slice(0, 4000));
+        if (!text)
+            return null;
+        return {
+            role: this.detectRole(node, text),
+            content: text,
+        };
+    }
+    detectRole(node, text) {
+        const marker = [
+            node.dataset.messageAuthorRole,
+            node.dataset.role,
+            node.getAttribute('data-role'),
+            node.getAttribute('aria-label'),
+            typeof node.className === 'string' ? node.className : '',
+            node.id,
+            node.closest('[data-message-author-role]')?.getAttribute('data-message-author-role'),
+        ]
+            .filter(Boolean)
+            .join(' ')
+            .toLowerCase();
+        if (/assistant|bot|ai|model|gpt|claude|copilot/.test(marker))
+            return 'assistant';
+        if (/user|human|prompt|customer|visitor/.test(marker))
+            return 'user';
+        if (/system/.test(marker))
+            return 'system';
+        if (/tool|function/.test(marker))
+            return 'tool';
+        const alignment = window.getComputedStyle(node).textAlign;
+        if (alignment === 'right')
+            return 'user';
+        const lower = text.toLowerCase();
+        if (lower.startsWith('you:'))
+            return 'user';
+        if (lower.startsWith('assistant:') || lower.startsWith('ai:'))
+            return 'assistant';
+        return 'unknown';
+    }
+    extractConversationTitle(container) {
+        const heading = container.querySelector('h1, h2, h3, [data-testid*="title" i], [class*="title"]');
+        return this.scrub(heading?.innerText?.trim().slice(0, 160) || document.title || 'conversation');
+    }
+    getConversationId(meta, container) {
+        const explicit = [
+            meta?.conversationId,
+            meta?.conversation_id,
+            meta?.threadId,
+            meta?.thread_id,
+            meta?.sessionId,
+            meta?.session_id,
+        ].find((value) => typeof value === 'string' && value.trim().length > 0);
+        if (explicit)
+            return this.scrub(explicit).slice(0, 120);
+        if (container) {
+            const existing = container.dataset.zcConversationId;
+            if (existing)
+                return existing;
+            const generated = `conv-${location.pathname.replace(/[^a-z0-9]+/gi, '-').replace(/^-|-$/g, '') || 'root'}-${++this.conversationCounter}`;
+            container.dataset.zcConversationId = generated;
+            return generated;
+        }
+        return `conv-${location.pathname.replace(/[^a-z0-9]+/gi, '-').replace(/^-|-$/g, '') || 'root'}-${Date.now()}`;
+    }
+    getMessageFingerprint(conversationId, message, index) {
+        return `${conversationId}:${index}:${message.role}:${message.content.slice(0, 240)}`;
+    }
+    safePathname(url) {
+        try {
+            return new URL(url, window.location.origin).pathname;
+        }
+        catch {
+            return url;
+        }
+    }
+    normalizeRole(value) {
+        if (typeof value !== 'string')
+            return 'unknown';
+        const normalized = value.toLowerCase();
+        if (normalized.includes('assistant') || normalized.includes('bot') || normalized.includes('ai') || normalized.includes('model'))
+            return 'assistant';
+        if (normalized.includes('user') || normalized.includes('human'))
+            return 'user';
+        if (normalized.includes('system'))
+            return 'system';
+        if (normalized.includes('tool') || normalized.includes('function'))
+            return 'tool';
+        return 'unknown';
+    }
+}